[CodeGen] Remove pending AssertZext AssertSext in promoting FP_TO_INT

[xiangzhangllvm]

Summary

Adding AssertZext AssertSext in promoting FP_TO_INT is not safe.

for example:
t3: v8i8 = fp_to_uint t2 --promote to--> t4: v8i16 = fp_to_sint t2 + t5: v8i16 = AssertZext t86, ValueType:ch:i8
will let following optimization see the "high 8-bits of each element of t5" == 0. (but it is not, it may be undef, when there is overflow in fp_to_uint )

So some setting t5's "high 8-bits of each element" action will be optimized out.
And finally cause calculation error.

Related commit: https://reviews.llvm.org/D40591
Related optimization: https://reviews.llvm.org/rG2a419a0b9957ebac9e11e4b43bc9fbe42a9207df

tests in llvm/test/CodeGen/X86/tmp is just for discussion, I will remove it at last.

[RKSimon]

llvm/lib/CodeGen/SelectionDAG/LegalizeVectorOps.cpp

715

The codegen diff is awful - what happens if you replace this with a SIGN_EXTEND_INREG / ZERO_EXTEND_INREG (AND) pattern?

[craig.topper]

If the conversion overflows the result is poison according to the IR langref. So is this really a problem?

Does the same code need to be removed from type legalization?

[efriedma]

I agree, the existing lowering seems fine. If it's causing problems for C code, there's probably a source bug, which should be caught by -fsanitize=undefined.

[efriedma]

To be clear, I'm working on the assumption that AssertZext means "if the operand is not poison, the high N bits are not set". I'm not sure we've formally stated that anywhere, but I think it's consistent with how SelectionDAG optimizations use AssertZext in practice.

[LuoYuanke]

In D106053#2881182, @efriedma wrote:

To be clear, I'm working on the assumption that AssertZext means "if the operand is not poison, the high N bits are not set". I'm not sure we've formally stated that anywhere, but I think it's consistent with how SelectionDAG optimizations use AssertZext in practice.

Is it possible that user expect some saturate behaviour (get the max value of the int) when convert from FP to INT overflow? AssertZext cause the undefined behaviour be propagated to each optimization that assume the upper bits being zero.

[craig.topper]

In D106053#2881878, @LuoYuanke wrote:

In D106053#2881182, @efriedma wrote:

To be clear, I'm working on the assumption that AssertZext means "if the operand is not poison, the high N bits are not set". I'm not sure we've formally stated that anywhere, but I think it's consistent with how SelectionDAG optimizations use AssertZext in practice.

Is it possible that user expect some saturate behaviour (get the max value of the int) when convert from FP to INT overflow? AssertZext cause the undefined behaviour be propagated to each optimization that assume the upper bits being zero.

It's undefined behavior according to C. The code would get different behavior on different platforms and shouldn't be relied on. We have fptosi_sat and fptoui_sat intrinsics that are used by rust that produce a well defined behavior on overflow. It doesn't look like we have a target independent builtin for them.

[craig.topper]

In D106053#2881905, @craig.topper wrote:

In D106053#2881878, @LuoYuanke wrote:

In D106053#2881182, @efriedma wrote:

To be clear, I'm working on the assumption that AssertZext means "if the operand is not poison, the high N bits are not set". I'm not sure we've formally stated that anywhere, but I think it's consistent with how SelectionDAG optimizations use AssertZext in practice.

Is it possible that user expect some saturate behaviour (get the max value of the int) when convert from FP to INT overflow? AssertZext cause the undefined behaviour be propagated to each optimization that assume the upper bits being zero.

It's undefined behavior according to C. The code would get different behavior on different platforms and shouldn't be relied on. We have fptosi_sat and fptoui_sat intrinsics that are used by rust that produce a well defined behavior on overflow. It doesn't look like we have a target independent builtin for them.

I'm not sure you get saturation with this assert removed. The result will be truncated to the original integer type. If the conversion overflowed the original type but not int32, you would just get the lower 8 or 16 bits of the conversion result. If it overflowed the conversion to int32, the cvt instruction produces INT_MIN and the truncate will turn it into 0.

[xiangzhangllvm]

This cause a runfail of a big project, Let me show key context of the test first:

%wide.insert226vector_func.i = shufflevector <32 x i8> %wide.insert224vector_func.i, <32 x i8> %extended.225vector_func.i, <32 x i32> <i32 0, i32 32, i32 undef, i32 3, i32 4, i32 33, i32 undef, i32 7, i32 8, i32 34, i32 undef, i32 11, i32 12, i32 35, i32 undef, i32 15, i32 16, i32 36, i32 undef, i32 19, i32 20, i32 37, i32 undef, i32 23, i32 24, i32 38, i32 undef, i32 27, i32 28, i32 39, i32 undef, i32 31>

it try to convert to (late me trunc the first 4 element of shuffle mask)

%wide.insert226vector_func.i0 = shufflevector <32 x i8> %wide.insert224vector_func.i, <32 x i8> --, <32 x i32> <i32 0, i32 zo, i32 undef, i32 3...> // zo means set here element = 0, -- means "can optimize out this operand"
%wide.insert226vector_func.i1 = shufflevector <32 x i8> %--, <32 x i8> %extended.225vector_func.i, <32 x i32> <i32 zo, i32 33, i32 zo, i32 zo...>
%wide.insert226vector_func.i = %wide.insert226vector_func.i0 | %wide.insert226vector_func.i1

But the first IR %wide.insert226vector_func.i0 can be directly replaced by its operand %wide.insert224vector_func.i when the index 1, 1+4, 1+2*4 ... is zero.
@RKSimon 's patch (optimization: https://reviews.llvm.org/rG2a419a0b9957ebac9e11e4b43bc9fbe42a9207df) will try check if related elements is zero, and @craig.topper 's patch happen generated AssertZext to show this element is zero.
But in fact , this element may be undef.

Let me upload the small reproduce test soon. (if you remove @RKSimon 's patch, that will be more obvious)

[xiangzhangllvm]

I'm working on assumption that AssertZext means "if the operand is not poison, the high N bits are not set"

And In fact, current optimizations on AssertZext don't care about its operand's poison or other details, it just thought its hight N bits are 0.
for example, in

"SelectionDAG::computeKnownBits" 
 3297   case ISD::AssertZext: {
 3298     EVT VT = cast<VTSDNode>(Op.getOperand(1))->getVT();
 3299     APInt InMask = APInt::getLowBitsSet(BitWidth, VT.getSizeInBits());
 3300     Known = computeKnownBits(Op.getOperand(0), Depth+1);
 3301     Known.Zero |= (~InMask);
 3302     Known.One  &= (~Known.Zero);
 3303     break;

You can see the high N bits directly be mark as zero.

[xiangzhangllvm]

This comment was removed by xiangzhangllvm.

[xiangzhangllvm]

In D106053#2881925, @xiangzhangllvm wrote:

And for "AssertZext ", both following DAG optimizations and ISel will not try generate node/MIR to clear its high N bits to zero. ISel will directly ignore it.

(I think it make sense, because it is just a flag/mark, it means its operand's high N bits already be 0)

[xiangzhangllvm]

upload llvm/test/CodeGen/X86/tmp

I tend not to commit this test at last, this is just for show the problem in discussion.

The diff is not cause by Current patch on the rep.ll (because it is not obviously)
The diff is caused by revert Simon's https://reviews.llvm.org/rG2a419a0b9957ebac9e11e4b43bc9fbe42a9207df or not.
(Simon's patch self is no problem, it is just show out the problem, the root cause is related with generating AssertZext)

[xiangzhangllvm]

Let me reformat/refine my upper comments:
This cause a runfail of a big project, Let me show key context of the test first:

%wide.insert226vector_func.i = shufflevector <32 x i8> %wide.insert224vector_func.i, <32 x i8> %extended.225vector_func.i, <32 x i32> <i32 0, i32 32, i32 undef, i32 3, i32 4, i32 33, i32 undef, i32 7, i32 8, i32 34, i32 undef, i32 11, i32 12, i32 35, i32 undef, i32 15, i32 16, i32 36, i32 undef, i32 19, i32 20, i32 37, i32 undef, i32 23, i32 24, i32 38, i32 undef, i32 27, i32 28, i32 39, i32 undef, i32 31>

it try to convert to (late me trunc the first 4 element of shuffle mask)

%wide.insert226vector_func.i0 = shufflevector <32 x i8> %wide.insert224vector_func.i, <32 x i8> --, <32 x i32> <i32 0, i32 zo, i32 undef, i32 3...> // zo means set here element = 0, -- means "can optimize out this operand"
%wide.insert226vector_func.i1 = shufflevector <32 x i8> %--, <32 x i8> %extended.225vector_func.i, <32 x i32> <i32 zo, i32 32, i32 zo, i32 zo...>
%wide.insert226vector_func.i = %wide.insert226vector_func.i0 | %wide.insert226vector_func.i1

But the first IR %wide.insert226vector_func.i0 can be directly replaced by its operand %wide.insert224vector_func.i when the element with index 1, 1+4, 1+2*4 ... is zero.

@RKSimon 's patch (optimization: https://reviews.llvm.org/rG2a419a0b9957ebac9e11e4b43bc9fbe42a9207df) will try check if related elements is zero, and @craig.topper 's patch happen generated AssertZext to show this element is zero.
But in fact , this element may be undef.

[craig.topper]

llvm/test/CodeGen/X86/tmp/rep.ll

27 ↗

(On Diff #359181)

Can you provide the values for %call.i24.i, %i384, %i385, %i386 in your failing case?

[craig.topper]

llvm/test/CodeGen/X86/tmp/rep.ll

14 ↗

(On Diff #359181)

Or is it this fptoui that overflowed?

[xiangzhangllvm]

llvm/test/CodeGen/X86/tmp/rep.ll

14 ↗

(On Diff #359181)

Yes, It is. We can't control the load value of %1 %2

27 ↗

(On Diff #359181)

This is just a small reproduce, in our project, if we clear the high 8 bits of the related element, the project will run pass.

[craig.topper]

llvm/test/CodeGen/X86/tmp/rep.ll

14 ↗

(On Diff #359181)

Where did it come from? Does the program fail -fsanitize=undefined?

[xiangzhangllvm]

llvm/test/CodeGen/X86/tmp/rep.ll

14 ↗

(On Diff #359181)

It come from a long way: a lot of fmul and fadd operations, also include calling some function.
What is the llc option "-fsanitize=undefined" corresponding to ? It is a OCL project with a log of cl files. It is much easy for me to use llc option.

[xiangzhangllvm]

Hello @craig.topper , what do you want to mean ?
Do you want to mean the load of float value should not overflow to i8 ?

[craig.topper]

llvm/test/CodeGen/X86/tmp/rep.ll

14 ↗

(On Diff #359181)

There isn't an llc option. The option makes clang include extra code in the binary to check the range of inputs on different operations.

How far out of range is the loaded data? Can you provide the values? What does the program expect the result of the fptoui to be?

[xiangzhangllvm]

llvm/test/CodeGen/X86/tmp/rep.ll

14 ↗

(On Diff #359181)

It is difficult for me to provide the value.
In fact, when I debug the problem, I also want to get the value, but the host program is not built from our project, it make me hard to print the middle value of kernel code.

Can we focus on this small reproduce cast ?
If we assume there is an over flow in this small case. We can compare the *.s I uppload. The rep_old.s is not correct.

[craig.topper]

In D106053#2882083, @xiangzhangllvm wrote:

Hello @craig.topper , what do you want to mean ?
Do you want to mean the load of float value should not overflow to i8 ?

If the loaded value is not in the range [0.0, 1.0] so that %i375 is in the range [0.0, 255.0], then I don't know what value the fptoui is supposed to produce.

[xiangzhangllvm]

If the loaded value is not in the range [0.0, 1.0] so that %i375 is in the range [0.0, 255.0], then I don't know what value the fptoui is supposed to produce.

Or we can see in this way.
In the edge calculation, we just need to load 4 elements of v8f32, but for performance reason, we usually load full (8) elements. So some of its loaded element has no meaning (may over flow).
So the shuffle don't select these element, but the shuffle may zero there element then for other use. (very just like this small reproduce case )

[craig.topper]

I'm confused. The AssertZext gets inserted by LegalizeIntegerTypes.cpp for this test case when the 8xi8 fptoui becomes an 8xi16 fptosi. LegalizeVectorOps inserts an AssertSext later when the v8i16 gets promoted to v8i32. This patch only gets rid of the AssertSext.

[xiangzhangllvm]

In D106053#2882145, @craig.topper wrote:

I'm confused. The AssertZext gets inserted by LegalizeIntegerTypes.cpp for this test case when the 8xi8 fptoui becomes an 8xi16 fptosi. LegalizeVectorOps inserts an AssertSext later when the v8i16 gets promoted to v8i32. This patch only gets rid of the AssertSext.

Because I am happen see your change about adding AssertZext at https://reviews.llvm.org/D40591, let me recheck other adding AssertZext at LegalizeIntegerTypes.cpp. Thanks for your remind!

[craig.topper]

In D106053#2882146, @xiangzhangllvm wrote:

In D106053#2882145, @craig.topper wrote:

I'm confused. The AssertZext gets inserted by LegalizeIntegerTypes.cpp for this test case when the 8xi8 fptoui becomes an 8xi16 fptosi. LegalizeVectorOps inserts an AssertSext later when the v8i16 gets promoted to v8i32. This patch only gets rid of the AssertSext.

Because I am happen see your change about adding AssertZext at https://reviews.llvm.org/D40591, let me recheck other adding AssertZext at LegalizeIntegerTypes.cpp. Thanks for your remind!

The same code also exists in X86TargetLowering::ReplaceNodeResults.

My confusion is that at multiple points in this discussion you mentioned AssertZext being what's causing the problem, but this patch doesn't affected the AssertZext in the test.

[xiangzhangllvm]

The same code also exists in X86TargetLowering::ReplaceNodeResults.

My confusion is that at multiple points in this discussion you mentioned AssertZext being what's causing the problem, but this patch doesn't affected the AssertZext in the test.

My mistake, I thought only here adding the AssertZext.
The project is very sensitive, even I fine tuning the order of the IR, it will fail to reproduce. So after I apply this patch, it not reproduce too, So I thought the fix "really" works.

[xiangzhangllvm]

I'll update the patch a little later, Thanks for your reviews.

[efriedma]

If I'm understanding correctly, the testcase reduces to something like this:

define <16 x i8> @src(<4 x float> %arg1) {
  %f = fptoui <4 x float> %arg1 to <4 x i8>
  %s = shufflevector <4 x i8> %f, <4 x i8> undef, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
  %ss = shufflevector <16 x i8> %s, <16 x i8> zeroinitializer, <16 x i32> <i32 0, i32 17, i32 18, i32 19, i32 1, i32 21, i32 22, i32 23, i32 2, i32 25, i32 26, i32 27, i32 3, i32 29, i32 30, i32 31>
  ret <16 x i8> %ss
}

define <16 x i8> @tgt(<4 x float> %arg1) {
  %f = fptosi <4 x float> %arg1 to <4 x i32>
  %ss = bitcast <4 x i32> %f to <16 x i8>
  ret <16 x i8> %ss
}

llc compiles both of these to a single cvttps2dq; alive2 says these are not equivalent. So apparently there's some disagreement within SelectionDAG about what AssertZext actually means.

I'd consider this a bug in the x86 shuffle code. Changing fptoui legalization would basically imply that poison doesn't exist in SelectionDAG, which is not the direction we want to go, I think.

[efriedma]

Err, wait, obviously they're not equivalent. Not

In D106053#2882183, @efriedma wrote:

llc compiles both of these to a single cvttps2dq; alive2 says these are not equivalent.

Err, wait, they're obviously not equivalent... not sure what I was thinking. Would need a different testcase.

Anyway, the general issue issue I'm getting at is that poison in vectors is supposed to apply separately to each element of the vector. Here, it's leaking across elements.

[xiangzhangllvm]

If you think the small reproduce rep.ll is not small enough, I'll go further to simplify it, but I am not 100% sure I will be successful.

[craig.topper]

llvm/lib/Target/X86/X86ISelLowering.cpp

30751–30752

This only exists because of the code you removed.

30751–30752

Same with this.

[xiangzhangllvm]

llvm/lib/Target/X86/X86ISelLowering.cpp

30751–30752

Got it, thanks a lot!!

[efriedma]

Marking request changes pending a response to the question of whether the usage of AssertZext here is actually incorrect.

[xiangzhangllvm]

In D106053#2884844, @efriedma wrote:

Marking request changes pending a response to the question of whether the usage of AssertZext here is actually incorrect.

I thought that is clear.

fptoui <8 x float> %1 to <8 x i8>   !=  fptosi <8 x float> %1 to <8 x i16>  +  AssertZext

In right side, when overflow, the high N bits is undef, but we mark them Zero with AssertZext.
The following optimizations (e.g. shuffle combine) tried to reset the high N bits to Zero, but it find AssertZext (which means the high N bits already Zero), so it stop reset them, this makes the error.

The small reproduce test case is just show in this way.

[xiangzhangllvm]

@efriedma We have a job blocked by this patch, so I hope we can quickly got the key point.

Let me duplicate my previous statement:

Or we can see in this way. 
In the edge calculation, we just need to load 4 elements of v8f32, but for performance reason, we usually load full (8) elements. So some of its loaded element has no meaning (may over flow).
So the shuffle don't select these element, but the shuffle may zero these elements then for other use. (very just like this small reproduce case )

+  After appending AssertZext, the shuffle optimization will stop zero these elements, and directly use them.   That is wrong.

[efriedma]

+ After appending AssertZext, the shuffle optimization will stop zero these elements, and directly use them. That is wrong.

I agree up to this point.

The question is, is the AssertZext node wrong, or are the shuffle optimizations wrong? That dictates whether we go with this patch, or instead revert 2a419a0b9957 (and any similar optimizations, if they exist).

---

In any case, we should probably add the following example as a regression test:

define <16 x i8> @src(<4 x float> %arg1) {
  %f = fptoui <4 x float> %arg1 to <4 x i8>
  %s = shufflevector <4 x i8> %f, <4 x i8> undef, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
  %ss = shufflevector <16 x i8> %s, <16 x i8> zeroinitializer, <16 x i32> <i32 0, i32 17, i32 18, i32 19, i32 1, i32 21, i32 22, i32 23, i32 2, i32 25, i32 26, i32 27, i32 3, i32 29, i32 30, i32 31>
  ret <16 x i8> %ss
}

[xiangzhangllvm]

In D106053#2885026, @efriedma wrote:

+ After appending AssertZext, the shuffle optimization will stop zero these elements, and directly use them. That is wrong.

I agree up to this point.

The question is, is the AssertZext node wrong, or are the shuffle optimizations wrong? That dictates whether we go with this patch, or instead revert 2a419a0b9957 (and any similar optimizations, if they exist).

It is the "adding AssertZext node" wrong. AssertZext node should correctly marked node which is really zero in N bits.

In any case, we should probably add the following example as a regression test:
...

No problem, Let me add the test soon, thanks you!

[xiangzhangllvm]

Address @efriedma 's comment, add test fptoui-may-overflow.ll, thanks very much!

[craig.topper]

Why does this patch not touch the code in DAGTypeLegalizer::PromoteIntRes_FP_TO_XINT? If the code in LegalizeVectorOps is a problem I think that code is too.

[aqjune]

llvm/test/CodeGen/X86/fptoui-may-overflow.ll

6

According to LangRef (https://llvm.org/docs/LangRef.html#fptoui-to-instruction), the overflow returns poison which means that using the value is invalid.

This is analogous to using an uninitialized variable in C/C++; there is no guarantee that the compiled program will have a reasonable behavior.

int x; // not initialized
printf("%d", x); // Assume that this printed 0xDEADBEEF
... (don't update x)
printf("%d", x); // There is no guarantee that this will also print 0xDEADBEEF

[efriedma]

In D106053#2885066, @xiangzhangllvm wrote:

In D106053#2885026, @efriedma wrote:

+ After appending AssertZext, the shuffle optimization will stop zero these elements, and directly use them. That is wrong.

I agree up to this point.

The question is, is the AssertZext node wrong, or are the shuffle optimizations wrong? That dictates whether we go with this patch, or instead revert 2a419a0b9957 (and any similar optimizations, if they exist).

It is the "adding AssertZext node" wrong. AssertZext node should correctly marked node which is really zero in N bits.

A lane of a vector is either poisoned, or not poisoned. It doesn't apply to individual bits of a vector.

Extending this to how computeKnownBits works, if computeKnownBits says a bit is "known", it doesn't really mean the bit has to have that value. It means either the bit has that value, or that lane of the vector is poisoned. As far as I know, this applies to both the SelectionDAG and the ValueTracking versions of computeKnownBits.

llvm/test/CodeGen/X86/fptoui-may-overflow.ll

6

The comment is wrong. But the CHECK lines are correct. LangRef and alive2 say the following transform is invalid:

define <16 x i8> @src(<4 x float> %arg1) {
  %ss = shufflevector <16 x i8> poison, <16 x i8> zeroinitializer, <16 x i32> <i32 0, i32 17, i32 18, i32 19, i32 1, i32 21, i32 22, i32 23, i32 2, i32 25, i32 26, i32 27, i32 3, i32 29, i32 30, i32 31>
  ret <16 x i8> %ss
}
=>
define <16 x i8> @tgt(<4 x float> %arg1) {
  ret <16 x i8> poison
}

(On a side-note, alive2 gives some confusing results for fptoui; apparently it thinks fptoui float 31.5 to i32 is poison.)

[xiangzhangllvm]

In D106053#2885131, @craig.topper wrote:

Why does this patch not touch the code in DAGTypeLegalizer::PromoteIntRes_FP_TO_XINT? If the code in LegalizeVectorOps is a problem I think that code is too.

Let me fix here too, thanks very much for your remind!

llvm/test/CodeGen/X86/fptoui-may-overflow.ll

6

Sorry, not much understand, Here the test didn't use poison elements, and we don't know the fptoui will be overflow or not, it is runtime.

[xiangzhangllvm]

Address Craig's comment: fix in PromoteIntRes_FP_TO_XINT too.

[craig.topper]

These changes cause test failures on other targets.

[xiangzhangllvm]

In D106053#2885253, @craig.topper wrote:

These changes cause test failures on other targets.

Yes, I first commit the change let you review, my local is build with '-DLLVM_TARGETS_TO_BUILD="all"', I'll update the other target tests after I finish the testing. Thank you again!

[aqjune]

In D106053#2882183, @efriedma wrote:

If I'm understanding correctly, the testcase reduces to something like this:

define <16 x i8> @src(<4 x float> %arg1) {
  %f = fptoui <4 x float> %arg1 to <4 x i8>
  %s = shufflevector <4 x i8> %f, <4 x i8> undef, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
  %ss = shufflevector <16 x i8> %s, <16 x i8> zeroinitializer, <16 x i32> <i32 0, i32 17, i32 18, i32 19, i32 1, i32 21, i32 22, i32 23, i32 2, i32 25, i32 26, i32 27, i32 3, i32 29, i32 30, i32 31>
  ret <16 x i8> %ss
}

define <16 x i8> @tgt(<4 x float> %arg1) {
  %f = fptosi <4 x float> %arg1 to <4 x i32>
  %ss = bitcast <4 x i32> %f to <16 x i8>
  ret <16 x i8> %ss
}

Other than reverting the patch, can %f in tgt be frozen? (Unless it is likely to cause performance regression; I found that updating vector ops to deal with freeze is hard work)?

llvm/test/CodeGen/X86/fptoui-may-overflow.ll

6

@efriedma Thank you for the report, I made a pull request at Alive2 that fixes the bugs. @nlopes will be back in a few weeks and have a look at it.

@xiangzhangllvm poison is kind of a conceptual value that appears in LLVM IR's abstract machine.
It is used to carry guarantees from C/C++ that e.g., casting big floats to signed integer is not legal.
Of course, one cannot statically determine if a C program will do such cast or not.
As double free raises segmentation fault, the execution can fail or print a bogus value; integer overflow is just less visible to users.

[xiangzhangllvm]

llvm/test/CodeGen/X86/fptoui-may-overflow.ll

6

Hi @aqjune ,let's talk on the test. The current problem is

"%f = fptoui <4 x float> %arg to <4 x i8>" will be convert to "fptosi <4 x float> %1 to <4 x i16> + AssertZext"

Do you mean in overflow case, %f should be poison value and report error ? (I agree)
But this convert self is not correct.
And even we mark some elements of %f is poison, but the following shuffle didn't use (read) this poison element. It just write 0 into these elements.
And this action of "write 0" will be remove by AssertZext. So this patch is try to removing this AssertZext.

[xiangzhangllvm]

Update the related tests.

[jrtc27]

llvm/test/CodeGen/AArch64/arm64-convert-v4f64.ll

26–28

Did the instruction count actually go down or did you just delete the instructions that were no longer present but not add new ones? You've certainly lost the CHECK line for the final instruction that puts all the temporary values into the return register.

llvm/test/CodeGen/RISCV/rv64d-double-convert.ll

25

All the RISC-V changes look like regressions to me unless I'm missing something...

[aqjune]

llvm/test/CodeGen/X86/fptoui-may-overflow.ll

6

"%f = fptoui <4 x float> %arg to <4 x i8>" will be convert to "fptosi <4 x float> %1 to <4 x i16> + AssertZext"

To me the transformation seems correct; let me explain why I think so.
I'll use <1 x float> instead of <4 x float> to avoid confusion; it seems the number of elements doesn't matter here.

Let's assume that %arg[0] fit in [0,256); then AssertZext is fine, because 8 MSBs of i16 is anyway zero.
The problematic case is when %arg[0] doesn't fit in [0, 256).
Then, %f[0] is poison; using %f[0] will raise undefined behavior.
Then, the optimized code can do anything including using the register which isn't filled with zero bits...
So in either case, having AssertZext is fine.

To me, efriedma's shufflevector transformation (https://reviews.llvm.org/D106053#2882183) looks fishier.
If 2a419a0b9957 is the root cause of the shufflevector transformation, and reverting it (or fixing it using freeze) solves the problem, then what do you think about the alternative solution?
2a419a0b9957 has small diffs in the tests which implies that it will have a small impact on performance, maybe.

[craig.topper]

Here's what I think is the issue. After type legalization we have a bitcast from <4 x i32> to <16 x i8>. When computeKnownBits sees a bitcast from a wider element type to a smaller element type, it converts DemandedElts into DemandedBits to try to get an answer from a portion of the wider input element elements.

How does poison interact with a bitcast from a wide element type to a narrower element type? Is what computeKnownBits does for this poison safe?

[efriedma]

In D106053#2885499, @craig.topper wrote:

How does poison interact with a bitcast from a wide element type to a narrower element type? Is what computeKnownBits does for this poison safe?

The rules for bitcast are pretty simple, I think: each element of the output vector depends on some number of elements in the input vector. (In the case of bitcast <4 x i32> to <16 x i8>, that's exactly one element.) If an output element depends on a poisoned input element, the result is poison.

I think computeKnownBits is handling this correctly.

Maybe the following will help clarify: consider the following example:

define <4 x i32> @src(<4 x float> %a) {
  %u = fptoui <4 x float> <float 256.0> to <4 x i8>
  %z = zext <4 x i8> %u to <4 x i32>
  %and = and <4 x i32> %z, <i32 255, i32 255, i32 255, i32 255>
  ret <4 x i32> %and
}

It is legal to optimize this to plain "poison". On the surface, this looks like the same thing as the shufflevector example, but shufflevector itself is sort of special: each element of the output is only poisoned if the corresponding source element is poisoned.

[craig.topper]

In D106053#2885500, @efriedma wrote:

In D106053#2885499, @craig.topper wrote:

How does poison interact with a bitcast from a wide element type to a narrower element type? Is what computeKnownBits does for this poison safe?

The rules for bitcast are pretty simple, I think: each element of the output vector depends on some number of elements in the input vector. (In the case of bitcast <4 x i32> to <16 x i8>, that's exactly one element.) If an output element depends on a poisoned input element, the result is poison.

I think computeKnownBits is handling this correctly.

Maybe the following will help clarify: consider the following example:

define <4 x i32> @src(<4 x float> %a) {
  %u = fptoui <4 x float> <float 256.0> to <4 x i8>
  %z = zext <4 x i8> %u to <4 x i32>
  %and = and <4 x i32> %z, <i32 255, i32 255, i32 255, i32 255>
  ret <4 x i32> %and
}

It is legal to optimize this to plain "poison". On the surface, this looks like the same thing as the shufflevector example, but shufflevector itself is sort of special: each element of the output is only poisoned if the corresponding source element is poisoned.

Ok that makes sense if the bitcast existed in IR. But this bitcast was created as part of type legalization and potentially spread poison to adjacent elements that didn't happen in the IR.

[efriedma]

Posted my counterproposal as https://reviews.llvm.org/D106222

[efriedma]

In D106053#2885502, @craig.topper wrote:

Ok that makes sense if the bitcast existed in IR. But this bitcast was created as part of type legalization and potentially spread poison to adjacent elements that didn't happen in the IR.

Are you asking if it's legal to turn src into tgt in the following?

define <4 x i8> @src(<1 x float> %a) {
  %u = fptoui <1 x float> %a to <1 x i8>
  %s = shufflevector <1 x i8> %u, <1 x i8> undef, <4 x i32> <i32 0, i32 undef, i32 undef, i32 undef>
  ret <4 x i8> %s
}

define <4 x i8> @tgt(<1 x float> %a) {
  %u = fptoui <1 x float> %a to <1 x i32>
  %and = bitcast <1 x i32> %u to <4 x i8>
  ret <4 x i8> %and
}

I think according to current LangRef rules, it technically isn't; we're turning undef into poison. But we're probably going to change shufflevector so we have "poison" in the shuffle mask instead of undef, so the result of the shufflevector has poison elements. So probably not worth spending time on this at the moment. See discussion on https://bugs.llvm.org/show_bug.cgi?id=44185 .

[efriedma]

In D106053#2885525, @efriedma wrote:

In D106053#2885502, @craig.topper wrote:

Ok that makes sense if the bitcast existed in IR. But this bitcast was created as part of type legalization and potentially spread poison to adjacent elements that didn't happen in the IR.

Oh, also, technically speaking, in fptoui-may-overflow.ll, the bitcast isn't getting created by type legalization; there's still a BUILD_VECTOR at that point. The bitcast is getting built by DAGCombine. From the debug dumps:

Type-legalized selection DAG: %bb.0 'fptoui_shuffle:'
SelectionDAG has 27 nodes:
  t0: ch = EntryToken
          t24: i32 = extract_vector_elt t19, Constant:i64<0>
        t25: i8 = truncate t24
          t27: i32 = extract_vector_elt t19, Constant:i64<1>
        t28: i8 = truncate t27
          t30: i32 = extract_vector_elt t19, Constant:i64<2>
        t31: i8 = truncate t30
          t33: i32 = extract_vector_elt t19, Constant:i64<3>
        t34: i8 = truncate t33
      t35: v16i8 = BUILD_VECTOR t25, t28, t31, t34, undef:i8, undef:i8, undef:i8, undef:i8, undef:i8, undef:i8, undef:i8, undef:i8, undef:i8, undef:i8, undef:i8, undef:i8
      t7: v16i8 = BUILD_VECTOR Constant:i8<0>, Constant:i8<0>, Constant:i8<0>, Constant:i8<0>, Constant:i8<0>, Constant:i8<0>, Constant:i8<0>, Constant:i8<0>, Constant:i8<0>, Constant:i8<0>, Constant:i8<0>, Constant:i8<0>, Constant:i8<0>, Constant:i8<0>, Constant:i8<0>, Constant:i8<0>
    t8: v16i8 = vector_shuffle<0,17,18,19,1,21,22,23,2,25,26,27,3,29,30,31> t35, t7
  t11: ch,glue = CopyToReg t0, Register:v16i8 $xmm0, t8
      t2: v4f32,ch = CopyFromReg t0, Register:v4f32 %0
    t17: v4i32 = fp_to_sint t2
  t19: v4i32 = AssertZext t17, ValueType:ch:i8
  t12: ch = X86ISD::RET_FLAG t11, TargetConstant:i32<0>, Register:v16i8 $xmm0, t11:1


Optimized type-legalized selection DAG: %bb.0 'fptoui_shuffle:'
SelectionDAG has 14 nodes:
  t0: ch = EntryToken
            t2: v4f32,ch = CopyFromReg t0, Register:v4f32 %0
          t17: v4i32 = fp_to_sint t2
        t19: v4i32 = AssertZext t17, ValueType:ch:i8
      t36: v16i8 = bitcast t19
      t7: v16i8 = BUILD_VECTOR Constant:i8<0>, Constant:i8<0>, Constant:i8<0>, Constant:i8<0>, Constant:i8<0>, Constant:i8<0>, Constant:i8<0>, Constant:i8<0>, Constant:i8<0>, Constant:i8<0>, Constant:i8<0>, Constant:i8<0>, Constant:i8<0>, Constant:i8<0>, Constant:i8<0>, Constant:i8<0>
    t48: v16i8 = vector_shuffle<0,17,18,19,4,21,22,23,8,25,26,27,12,29,30,31> t36, t7
  t11: ch,glue = CopyToReg t0, Register:v16i8 $xmm0, t48
  t12: ch = X86ISD::RET_FLAG t11, TargetConstant:i32<0>, Register:v16i8 $xmm0, t11:1

[RKSimon]

Its been a a long week and with that and timezone differences I have been really struggling to keep up with the pace and direction of this patch - are you saying that we can't depend on value tracking in the DAG for manipulation of vector elements? If D106222 make this whole thing go away then so be it, but all its doing is asking if a blend with zero shuffle is necessary or if that element is already known to be zero - we do a lot of other similar combines for shuffles (packs relying on zero/sign upper bits etc.) and otherwise.

[efriedma]

The one-line summary: if computeKnownBits says a bit is "known", it means either the bit has that value, or that lane of the vector is poisoned.

For almost all optimizations, the possibility of poison doesn't matter: if the source lane is poison, the result lane is also poison. However, this means the 2a419a0b transform isn't safe: if a lane in the result of a shufflevector is supposed to be zero, it has to actually be zero, not zero-or-poison. We could recover the optimization for the cases where it's legal with some form of isGuaranteedNotToBePoison().

Some other shuffle transforms might also run into trouble with poison? For example, matchShuffleWithPACK is wrong, I think, but the problem isn't the use of MaskedValueIsZero. The issue is the use of getBitcast(): if you bitcast from <4 x i8> to <1 x i32>, the 32-bit lane is poison if any of the input i8 lanes are poison.

[RKSimon]

OK thanks for getting me up to speed - I'll take a look at matchShuffleWithPACK (creating those bitcasts on the fly has been a problem for ages as it also affects one use tests....)

[xiangzhangllvm]

llvm/test/CodeGen/AArch64/arm64-convert-v4f64.ll

26–28

Sorry for I didn't familiar with aarch64 instructions, I didn't clear about what uzp1 mean, and the result didn't have these uzp1 instructions, So I dele them.
Can I update it with utils/update_llc_test_checks.py ?

llvm/test/CodeGen/RISCV/rv64d-double-convert.ll

25

Yes, if it base on the PromoteIntRes_FP_TO_XINT

llvm/test/CodeGen/X86/fptoui-may-overflow.ll

6

I think the key of our discussion should base on the correctness of the transformation.

The logic of 2a419a0b9957 self is no problem, it base on the how the computeKnownBits handle the AssertZext.
Now the IR already be

"fptosi <4 x float> %1 to <4 x i16> + AssertZext  i8"

If you think the transformation is correct, how can we know there is poison bits ?
AssertZext self do not contain the "poison" meaning that the bits 8-15 is poison.
it should just tell a truth that the high N bits is zero.

[efriedma]

llvm/test/CodeGen/X86/fptoui-may-overflow.ll

6

It's hard to give good examples involving poison in SelectionDAG, generally. Most of the focus of poison-based optimizations has been at the IR level, IR has better documentation, and Alive2 also only works at the IR level. So it's easier to discuss examples in IR as much as possible.

For now, let's put aside the discussion of the semantics of AssertZext.

In IR, the following transform is illegal, according to LangRef, and Alive2:

define <16 x i8> @src() {
  %and = and <4 x i32> poison, <i32 255, i32 255, i32 255, i32 255>
  %bitcast = bitcast <4 x i32> %and to <16 x i8>
  %ss = shufflevector <16 x i8> %bitcast, <16 x i8> zeroinitializer, <16 x i32> <i32 0, i32 17, i32 18, i32 19, i32 1, i32 21, i32 22, i32 23, i32 2, i32 25, i32 26, i32 27, i32 3, i32 29, i32 30, i32 31>
  ret <16 x i8> %ss
}

define <16 x i8> @tgt() {
  %and = and <4 x i32> poison, <i32 255, i32 255, i32 255, i32 255>
  %bitcast = bitcast <4 x i32> %and to <16 x i8>
  ret <16 x i8> %bitcast
}

Does this make sense?

I think 2a419a0b9957 performs the equivalent transform on SelectionDAG nodes. Do you think my understanding here is correct? Or is the SelectionDAG transform different somehow?

[xiangzhangllvm]

llvm/test/CodeGen/X86/fptoui-may-overflow.ll

6

Hi @efriedma, Yes, I agree/understand the "In IR, the following transform is illegal" in your test, because we can obvious see there is poison value. thanks.

But I don't understand why " 2a419a0b9957 performs the equivalent transform on SelectionDAG nodes"

The MaskedElementsAreZero didn't know the element is poison in fptoui-may-overflow.ll. It just check the common bits of DemandedElts, which not mark with poison.

[efriedma]

llvm/test/CodeGen/X86/fptoui-may-overflow.ll

6

The following is also illegal to transform because %a might be poison:

define <16 x i8> @src(<4 x i32> %a) {
  %and = and <4 x i32> %a, <i32 255, i32 255, i32 255, i32 255>
  %bitcast = bitcast <4 x i32> %and to <16 x i8>
  %ss = shufflevector <16 x i8> %bitcast, <16 x i8> zeroinitializer, <16 x i32> <i32 0, i32 17, i32 18, i32 19, i32 4, i32 21, i32 22, i32 23, i32 8, i32 25, i32 26, i32 27, i32 12, i32 29, i32 30, i32 31>
  ret <16 x i8> %ss
}

define <16 x i8> @tgt(<4 x i32> %a) {
  %and = and <4 x i32> %a, <i32 255, i32 255, i32 255, i32 255>
  %bitcast = bitcast <4 x i32> %and to <16 x i8>
  ret <16 x i8> %bitcast
}

In this situation, computeKnownBits will return that the high bits of %and are known zero.

Why does it do this? We just said that it might be poison, so they're not known. But as it turns out, this relaxed notion of a bit being "known" is generally more useful. Almost all IR transformations involve transforming an expression from one form to another. And for almost all IR expressions, a poison input implies a poison result.

For places that do actually care that a value isn't poison, there are various ways we could express the alternate semantics. We could add an alternate mode to computeKnownBits that doesn't return any known bits for values which might be poison. Or we can change the transform in question to call isGuaranteedNotToBePoison, or something like that. But that currently doesn't exist in SelectionDAG, so someone would need to write it.

[LuoYuanke]

@efriedma, thank you for make the issue more clear. So the poison value is different to undef value. For poison value, we should not should assume it is zero value, but for undef value it is not harmful to assume the value is zero. Right?

I notice in the function SelectionDAG::computeKnownBits , the code assume the upper bit is zero (Known.Zero |= (~InMask);). Since the upper bit may be poison value, is it correct?

case ISD::AssertZext: {
  EVT VT = cast<VTSDNode>(Op.getOperand(1))->getVT();
  APInt InMask = APInt::getLowBitsSet(BitWidth, VT.getSizeInBits());
  Known = computeKnownBits(Op.getOperand(0), Depth+1);
  Known.Zero |= (~InMask);
  Known.One  &= (~Known.Zero);
  break;
}

[RKSimon]

I've raised https://bugs.llvm.org/show_bug.cgi?id=51129 to track adding a llvm::isGuaranteedNotToBePoison(SDValue) helper method

[RKSimon]

@LuoYuanke AFAICT the current implementation is fine, we've just got to be more explicit that the DAG value tracking doesn't track poison.

From D106222: "I think we're going to have to add something to the SelectionDAG::computeKnownBits/ComputeNumSignBits doxygen comments explaining that the value could have the determined known/signbits BUT it could be a poison value (or if a vector any demanded element could be poison value)."

Random thought - the GlobalISel value tracking is less developed, could we improve handling for potential poison values to it before it gets too complicated?

[xiangzhangllvm]

@efriedma, Thanks you for explain, I am much clear about that. (And sorry for my late respond, I got a long travel yesterday)

Or Maybe we can replace the AssertZext with AssertZextOrPoison in "May Be Poison" case ?
If it is much easier to change all the existed optimizations.

Anyway, I suggest let us first revert 2a419a0b9957 (= D106222) , because we have a job blocked by this problem and we already find it really has problem.

[efriedma]

In D106053#2886341, @xiangzhangllvm wrote:

Or Maybe we can replace the AssertZext with AssertZextOrPoison in "May Be Poison" case ?

Not sure renaming AssertZext to AssertZextOrPoison really helps readability, but we should update the documentation in ISDOpcodes.h.

[aemerson]

In D106053#2885960, @RKSimon wrote:

@LuoYuanke AFAICT the current implementation is fine, we've just got to be more explicit that the DAG value tracking doesn't track poison.

From D106222: "I think we're going to have to add something to the SelectionDAG::computeKnownBits/ComputeNumSignBits doxygen comments explaining that the value could have the determined known/signbits BUT it could be a poison value (or if a vector any demanded element could be poison value)."

Random thought - the GlobalISel value tracking is less developed, could we improve handling for potential poison values to it before it gets too complicated?

The implementation of computeKnownBits is very similar to the one in SelectionDAG. Having tried to catch up on these threads, I'm not sure what's really missing though except for some clearer documentation?

[RKSimon]

In D106053#2886446, @aemerson wrote:

In D106053#2885960, @RKSimon wrote:

@LuoYuanke AFAICT the current implementation is fine, we've just got to be more explicit that the DAG value tracking doesn't track poison.

From D106222: "I think we're going to have to add something to the SelectionDAG::computeKnownBits/ComputeNumSignBits doxygen comments explaining that the value could have the determined known/signbits BUT it could be a poison value (or if a vector any demanded element could be poison value)."

Random thought - the GlobalISel value tracking is less developed, could we improve handling for potential poison values to it before it gets too complicated?

The implementation of computeKnownBits is very similar to the one in SelectionDAG. Having tried to catch up on these threads, I'm not sure what's really missing though except for some clearer documentation?

I've trying to think if there would be a decent way to run the value tracking calls in a 'no poison' mode (working with isGuaranteedNotToBePoison functionality) - and I was wondering if it'd be easier to develop in GISel first which has accumulated less baggage so far.

[RKSimon]

Can this be abandoned now?

[xiangzhangllvm]

In D106053#2890071, @RKSimon wrote:

Can this be abandoned now?

Let me abandon it first.
If you has a new fix patch, Please note here.

For "a decent way", How about set a flag in the IR/Node for the no-poison (or "maybe poison") value, I think it not just useful in DAG optimization, but also in IPO.

[RKSimon]

Just to be clear - D106222 unblocked the issue you were seeing?

[xiangzhangllvm]

In D106053#2892622, @RKSimon wrote:

Just to be clear - D106222 unblocked the issue you were seeing?

Yes, D106222 fixed my blocked issue too (a shuffle combine problem), thank you!

llvm/lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp

if (N->isStrictFPOpcode()) {
     Res = DAG.getNode(NewOpc, dl, {NVT, MVT::Other},
                       {N->getOperand(0), N->getOperand(1)});
     // Legalize the chain result - switch anything that used the old chain to
     // use the new one.
     ReplaceValueWith(SDValue(N, 1), Res.getValue(1));
   } else
     Res = DAG.getNode(NewOpc, dl, NVT, N->getOperand(0));
 
-  // Assert that the converted value fits in the original type.  If it doesn't
-  // (eg: because the value being converted is too big), then the result of the
-  // original operation was undefined anyway, so the assert is still correct.
-  //
-  // NOTE: fp-to-uint to fp-to-sint promotion guarantees zero extend. For example:
-  //   before legalization: fp-to-uint16, 65534. -> 0xfffe
-  //   after legalization: fp-to-sint32, 65534. -> 0x0000fffe
-  return DAG.getNode((N->getOpcode() == ISD::FP_TO_UINT ||
-                      N->getOpcode() == ISD::STRICT_FP_TO_UINT) ?
-                     ISD::AssertZext : ISD::AssertSext, dl, NVT, Res,
-                     DAG.getValueType(N->getValueType(0).getScalarType()));
+  return Res;
 }
 
 SDValue DAGTypeLegalizer::PromoteIntRes_FP_TO_XINT_SAT(SDNode *N) {
   // Promote the result type, while keeping the original width in Op1.
   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
   SDLoc dl(N);
   return DAG.getNode(N->getOpcode(), dl, NVT, N->getOperand(0),
                      N->getOperand(1));

llvm/lib/CodeGen/SelectionDAG/LegalizeVectorOps.cpp

void VectorLegalizer::PromoteFP_TO_INT(SDNode *Node,
   SDValue Promoted, Chain;
   if (IsStrict) {
     Promoted = DAG.getNode(NewOpc, dl, {NVT, MVT::Other},
                            {Node->getOperand(0), Node->getOperand(1)});
     Chain = Promoted.getValue(1);
   } else
     Promoted = DAG.getNode(NewOpc, dl, NVT, Node->getOperand(0));
 
-  // Assert that the converted value fits in the original type.  If it doesn't
-  // (eg: because the value being converted is too big), then the result of the
-  // original operation was undefined anyway, so the assert is still correct.
-  if (Node->getOpcode() == ISD::FP_TO_UINT ||
-      Node->getOpcode() == ISD::STRICT_FP_TO_UINT)
-    NewOpc = ISD::AssertZext;
-  else
-    NewOpc = ISD::AssertSext;
-
-  Promoted = DAG.getNode(NewOpc, dl, NVT, Promoted,
-                         DAG.getValueType(VT.getScalarType()));
   Promoted = DAG.getNode(ISD::TRUNCATE, dl, VT, Promoted);
   Results.push_back(Promoted);
   if (IsStrict)
     Results.push_back(Chain);
 }
 
 std::pair<SDValue, SDValue> VectorLegalizer::ExpandLoad(SDNode *N) {
   LoadSDNode *LD = cast<LoadSDNode>(N);

llvm/lib/Target/X86/X86ISelLowering.cpp

if (VT.isVector() && VT.getScalarSizeInBits() < 32) {
       SDValue Res;
       SDValue Chain;
       if (IsStrict) {
         Res = DAG.getNode(ISD::STRICT_FP_TO_SINT, dl, {PromoteVT, MVT::Other},
                           {N->getOperand(0), Src});
         Chain = Res.getValue(1);
       } else
         Res = DAG.getNode(ISD::FP_TO_SINT, dl, PromoteVT, Src);
 
-      // Preserve what we know about the size of the original result. If the
-      // result is v2i32, we have to manually widen the assert.
-      if (PromoteVT == MVT::v2i32)
-        Res = DAG.getNode(ISD::CONCAT_VECTORS, dl, MVT::v4i32, Res,
-                          DAG.getUNDEF(MVT::v2i32));
-
-      Res = DAG.getNode(!IsSigned ? ISD::AssertZext : ISD::AssertSext, dl,
-                        Res.getValueType(), Res,
-                        DAG.getValueType(VT.getVectorElementType()));
-
-      if (PromoteVT == MVT::v2i32)
-        Res = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MVT::v2i32, Res,
-                          DAG.getIntPtrConstant(0, dl));
-
       // Truncate back to the original width.
       Res = DAG.getNode(ISD::TRUNCATE, dl, VT, Res);
 
       // Now widen to 128 bits.
       unsigned NumConcats = 128 / VT.getSizeInBits();
       MVT ConcatVT = MVT::getVectorVT(VT.getSimpleVT().getVectorElementType(),
                                       VT.getVectorNumElements() * NumConcats);
       SmallVector<SDValue, 8> ConcatOps(NumConcats, DAG.getUNDEF(VT));
       ConcatOps[0] = Res;

llvm/test/CodeGen/AArch64/arm64-convert-v4f64.ll

 ; CHECK-DAG:  fcvtzs  v[[CONV0:[0-9]+]].2d, v0.2d
 ; CHECK-DAG:  fcvtzs  v[[CONV1:[0-9]+]].2d, v1.2d
 ; CHECK-DAG:  fcvtzs  v[[CONV2:[0-9]+]].2d, v2.2d
 ; CHECK-DAG:  fcvtzs  v[[CONV3:[0-9]+]].2d, v3.2d
 ; CHECK-DAG:  xtn  v[[XTN0:[0-9]+]].2s, v[[CONV0]].2d
 ; CHECK-DAG:  xtn  v[[XTN1:[0-9]+]].2s, v[[CONV1]].2d
 ; CHECK-DAG:  xtn  v[[XTN2:[0-9]+]].2s, v[[CONV2]].2d
 ; CHECK-DAG:  xtn  v[[XTN3:[0-9]+]].2s, v[[CONV3]].2d
-; CHECK-DAG:  uzp1 v[[UZP0:[0-9]+]].4h, v[[XTN1]].4h, v[[XTN0]].4h
-; CHECK-DAG:  uzp1 v[[UZP1:[0-9]+]].4h, v[[XTN3]].4h, v[[XTN2]].4h
-; CHECK:      uzp1  v0.8b, v[[UZP1:[0-9]+]].8b, v[[UZP0:[0-9]+]].8b
   %tmp1 = load <8 x double>, <8 x double>* %ptr
   %tmp2 = fptosi <8 x double> %tmp1 to <8 x i8>
   ret <8 x i8> %tmp2
 }
 
 define <4 x half> @uitofp_v4i64_to_v4f16(<4 x i64>* %ptr) {
 ; CHECK: uitofp_v4i64_to_v4f16
 ; CHECK-DAG: ucvtf  v[[LHS:[0-9]+]].2d, v0.2d

llvm/test/CodeGen/AArch64/fptouint-i8-zext.ll

 ; RUN: llc < %s | FileCheck %s
 
 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
 target triple = "aarch64"
 
 ; If the float value is negative or too large, the result is undefined anyway;
 ; otherwise, fcvtzs must returns a value in [0, 256), which guarantees zext.
 
 ; CHECK-LABEL: float_char_int_func:
 ; CHECK: fcvtzs [[A:w[0-9]+]], s0
+; CHECK-NEXT:    and w0, [[A:w[0-9]+]], #0xff
 ; CHECK-NEXT: ret
 define i32 @float_char_int_func(float %infloatVal) {
 entry:
   %conv = fptoui float %infloatVal to i8
   %conv1 = zext i8 %conv to i32
   ret i32 %conv1
 }

llvm/test/CodeGen/AMDGPU/fp_to_uint.ll

 ; VI-NEXT:    s_waitcnt lgkmcnt(0)
 ; VI-NEXT:    v_cvt_u32_f32_e32 v0, s2
 ; VI-NEXT:    s_mov_b32 s2, -1
 ; VI-NEXT:    buffer_store_short v0, off, s[0:3], 0
 ; VI-NEXT:    s_endpgm
 ;
 ; EG-LABEL: fp_to_uint_f32_to_i16:
 ; EG:       ; %bb.0:
-; EG-NEXT:    ALU 12, @4, KC0[CB0:0-32], KC1[]
+; EG-NEXT:    ALU 13, @4, KC0[CB0:0-32], KC1[]
 ; EG-NEXT:    MEM_RAT MSKOR T0.XW, T1.X
 ; EG-NEXT:    CF_END
 ; EG-NEXT:    PAD
 ; EG-NEXT:    ALU clause starting at 4:
 ; EG-NEXT:     TRUNC T0.W, KC0[2].Z,
 ; EG-NEXT:     AND_INT * T1.W, KC0[2].Y, literal.x,
 ; EG-NEXT:    3(4.203895e-45), 0(0.000000e+00)
-; EG-NEXT:     LSHL T1.W, PS, literal.x,
 ; EG-NEXT:     FLT_TO_UINT * T0.X, PV.W,
-; EG-NEXT:    3(4.203895e-45), 0(0.000000e+00)
-; EG-NEXT:     LSHL T0.X, PS, PV.W,
-; EG-NEXT:     LSHL * T0.W, literal.x, PV.W,
+; EG-NEXT:     AND_INT T0.W, PS, literal.x,
+; EG-NEXT:     LSHL * T1.W, T1.W, literal.y,
+; EG-NEXT:    65535(9.183409e-41), 3(4.203895e-45)
+; EG-NEXT:     LSHL T0.X, PV.W, PS,
+; EG-NEXT:     LSHL * T0.W, literal.x, PS,
 ; EG-NEXT:    65535(9.183409e-41), 0(0.000000e+00)
 ; EG-NEXT:     MOV T0.Y, 0.0,
 ; EG-NEXT:     MOV * T0.Z, 0.0,
 ; EG-NEXT:     LSHR * T1.X, KC0[2].Y, literal.x,
 ; EG-NEXT:    2(2.802597e-45), 0(0.000000e+00)
   %uint = fptoui float %in to i16
   store i16 %uint, i16 addrspace(1)* %out
   ret void
 }
 
 attributes #0 = { nounwind }
 attributes #1 = { nounwind readnone }

llvm/test/CodeGen/AMDGPU/fptoui.f16.ll

 }
 
 ; GCN-LABEL: {{^}}fptoui_v2f16_to_v2i16
 ; GCN:     buffer_load_dword v[[A_V2_F16:[0-9]+]]
 
 ; SI:     v_lshrrev_b32_e32 v[[A_F16_1:[0-9]+]], 16, v[[A_V2_F16]]
 ; SI-DAG: v_cvt_f32_f16_e32 v[[A_F32_1:[0-9]+]], v[[A_F16_1]]
 ; SI-DAG: v_cvt_f32_f16_e32 v[[A_F32_0:[0-9]+]], v[[A_V2_F16]]
-; SI:      v_cvt_u32_f32_e32 v[[R_I16_1:[0-9]+]], v[[A_F32_1]]
-; SI:      v_cvt_u32_f32_e32 v[[R_I16_0:[0-9]+]], v[[A_F32_0]]
+; SI-DAG: v_cvt_u32_f32_e32 v[[R_I16_1:[0-9]+]], v[[A_F32_1]]
+; SI-DAG: v_cvt_u32_f32_e32 v[[R_I16_0:[0-9]+]], v[[A_F32_0]]
+; SI:     v_and_b32_e32
 ; SI:     v_lshlrev_b32_e32 v[[R_I16_HI:[0-9]+]], 16, v[[R_I16_1]]
 ; SI:     v_or_b32_e32 v[[R_V2_I16:[0-9]+]], v[[R_I16_0]], v[[R_I16_HI]]
 
 ; VI:     v_cvt_u16_f16_e32 v[[A_U16_1:[0-9]+]], v[[A_V2_F16]]
 ; VI:     v_cvt_u16_f16_sdwa v[[R_U16_0:[0-9]+]], v[[A_V2_F16]] dst_sel:WORD_1 dst_unused:UNUSED_PAD src0_sel:WORD_1
 ; VI:     v_or_b32_sdwa v[[R_V2_I16:[0-9]+]], v[[A_U16_1]], v[[R_U16_0]] dst_sel:DWORD dst_unused:UNUSED_PAD src0_sel:WORD_0 src1_sel:DWORD
 
 ; GCN:     buffer_store_dword v[[R_V2_I16]]

llvm/test/CodeGen/PowerPC/f128-truncateNconv.ll

 
 ; Function Attrs: norecurse nounwind readonly
 define signext i16 @qpConv2shw(fp128* nocapture readonly %a) {
 ; CHECK-LABEL: qpConv2shw:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lxv v2, 0(r3)
 ; CHECK-NEXT:    xscvqpswz v2, v2
 ; CHECK-NEXT:    mfvsrwz r3, v2
-; CHECK-NEXT:    extsw r3, r3
+; CHECK-NEXT:    extsh r3, r3
 ; CHECK-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: qpConv2shw:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    mflr r0
 ; CHECK-P8-NEXT:    std r0, 16(r1)
 ; CHECK-P8-NEXT:    stdu r1, -32(r1)
 ; CHECK-P8-NEXT:    .cfi_def_cfa_offset 32
 ; CHECK-P8-NEXT:    .cfi_offset lr, 16
 ; CHECK-P8-NEXT:    lvx v2, 0, r3
 ; CHECK-P8-NEXT:    bl __fixkfsi
 ; CHECK-P8-NEXT:    nop
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsh r3, r3
 ; CHECK-P8-NEXT:    addi r1, r1, 32
 ; CHECK-P8-NEXT:    ld r0, 16(r1)
 ; CHECK-P8-NEXT:    mtlr r0
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = load fp128, fp128* %a, align 16
   %conv = fptosi fp128 %0 to i16
   ret i16 %conv

 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lxv v2, 0(r3)
 ; CHECK-NEXT:    addis r3, r2, .LC0@toc@ha
 ; CHECK-NEXT:    ld r3, .LC0@toc@l(r3)
 ; CHECK-NEXT:    lxv v3, 16(r3)
 ; CHECK-NEXT:    xsaddqp v2, v2, v3
 ; CHECK-NEXT:    xscvqpswz v2, v2
 ; CHECK-NEXT:    mfvsrwz r3, v2
-; CHECK-NEXT:    extsw r3, r3
+; CHECK-NEXT:    extsh r3, r3
 ; CHECK-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: qpConv2shw_03:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    mflr r0
 ; CHECK-P8-NEXT:    std r0, 16(r1)
 ; CHECK-P8-NEXT:    stdu r1, -32(r1)
 ; CHECK-P8-NEXT:    .cfi_def_cfa_offset 32
 ; CHECK-P8-NEXT:    .cfi_offset lr, 16
 ; CHECK-P8-NEXT:    addis r4, r2, .LC0@toc@ha
 ; CHECK-P8-NEXT:    lvx v2, 0, r3
 ; CHECK-P8-NEXT:    ld r4, .LC0@toc@l(r4)
 ; CHECK-P8-NEXT:    addi r4, r4, 16
 ; CHECK-P8-NEXT:    lvx v3, 0, r4
 ; CHECK-P8-NEXT:    bl __addkf3
 ; CHECK-P8-NEXT:    nop
 ; CHECK-P8-NEXT:    bl __fixkfsi
 ; CHECK-P8-NEXT:    nop
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsh r3, r3
 ; CHECK-P8-NEXT:    addi r1, r1, 32
 ; CHECK-P8-NEXT:    ld r0, 16(r1)
 ; CHECK-P8-NEXT:    mtlr r0
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = load fp128, fp128* %a, align 16
   %1 = load fp128, fp128* getelementptr inbounds
                             ([4 x fp128], [4 x fp128]* @f128Array,

 
 ; Function Attrs: norecurse nounwind readonly
 define zeroext i16 @qpConv2uhw(fp128* nocapture readonly %a) {
 ; CHECK-LABEL: qpConv2uhw:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lxv v2, 0(r3)
 ; CHECK-NEXT:    xscvqpswz v2, v2
 ; CHECK-NEXT:    mfvsrwz r3, v2
-; CHECK-NEXT:    clrldi r3, r3, 32
+; CHECK-NEXT:    clrldi r3, r3, 48
 ; CHECK-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: qpConv2uhw:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    mflr r0
 ; CHECK-P8-NEXT:    std r0, 16(r1)
 ; CHECK-P8-NEXT:    stdu r1, -32(r1)
 ; CHECK-P8-NEXT:    .cfi_def_cfa_offset 32
 ; CHECK-P8-NEXT:    .cfi_offset lr, 16
 ; CHECK-P8-NEXT:    lvx v2, 0, r3
 ; CHECK-P8-NEXT:    bl __fixkfsi
 ; CHECK-P8-NEXT:    nop
+; CHECK-P8-NEXT:    clrldi r3, r3, 48
 ; CHECK-P8-NEXT:    addi r1, r1, 32
 ; CHECK-P8-NEXT:    ld r0, 16(r1)
 ; CHECK-P8-NEXT:    mtlr r0
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = load fp128, fp128* %a, align 16
   %conv = fptoui fp128 %0 to i16
   ret i16 %conv

 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lxv v2, 0(r3)
 ; CHECK-NEXT:    addis r3, r2, .LC0@toc@ha
 ; CHECK-NEXT:    ld r3, .LC0@toc@l(r3)
 ; CHECK-NEXT:    lxv v3, 16(r3)
 ; CHECK-NEXT:    xsaddqp v2, v2, v3
 ; CHECK-NEXT:    xscvqpswz v2, v2
 ; CHECK-NEXT:    mfvsrwz r3, v2
-; CHECK-NEXT:    clrldi r3, r3, 32
+; CHECK-NEXT:    clrldi r3, r3, 48
 ; CHECK-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: qpConv2uhw_03:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    mflr r0
 ; CHECK-P8-NEXT:    std r0, 16(r1)
 ; CHECK-P8-NEXT:    stdu r1, -32(r1)
 ; CHECK-P8-NEXT:    .cfi_def_cfa_offset 32
 ; CHECK-P8-NEXT:    .cfi_offset lr, 16
 ; CHECK-P8-NEXT:    addis r4, r2, .LC0@toc@ha
 ; CHECK-P8-NEXT:    lvx v2, 0, r3
 ; CHECK-P8-NEXT:    ld r4, .LC0@toc@l(r4)
 ; CHECK-P8-NEXT:    addi r4, r4, 16
 ; CHECK-P8-NEXT:    lvx v3, 0, r4
 ; CHECK-P8-NEXT:    bl __addkf3
 ; CHECK-P8-NEXT:    nop
 ; CHECK-P8-NEXT:    bl __fixkfsi
 ; CHECK-P8-NEXT:    nop
+; CHECK-P8-NEXT:    clrldi r3, r3, 48
 ; CHECK-P8-NEXT:    addi r1, r1, 32
 ; CHECK-P8-NEXT:    ld r0, 16(r1)
 ; CHECK-P8-NEXT:    mtlr r0
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = load fp128, fp128* %a, align 16
   %1 = load fp128, fp128* getelementptr inbounds
                             ([4 x fp128], [4 x fp128]* @f128Array,

 
 ; Function Attrs: norecurse nounwind readonly
 define signext i8 @qpConv2sb(fp128* nocapture readonly %a) {
 ; CHECK-LABEL: qpConv2sb:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lxv v2, 0(r3)
 ; CHECK-NEXT:    xscvqpswz v2, v2
 ; CHECK-NEXT:    mfvsrwz r3, v2
-; CHECK-NEXT:    extsw r3, r3
+; CHECK-NEXT:    extsb r3, r3
 ; CHECK-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: qpConv2sb:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    mflr r0
 ; CHECK-P8-NEXT:    std r0, 16(r1)
 ; CHECK-P8-NEXT:    stdu r1, -32(r1)
 ; CHECK-P8-NEXT:    .cfi_def_cfa_offset 32
 ; CHECK-P8-NEXT:    .cfi_offset lr, 16
 ; CHECK-P8-NEXT:    lvx v2, 0, r3
 ; CHECK-P8-NEXT:    bl __fixkfsi
 ; CHECK-P8-NEXT:    nop
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsb r3, r3
 ; CHECK-P8-NEXT:    addi r1, r1, 32
 ; CHECK-P8-NEXT:    ld r0, 16(r1)
 ; CHECK-P8-NEXT:    mtlr r0
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = load fp128, fp128* %a, align 16
   %conv = fptosi fp128 %0 to i8
   ret i8 %conv

 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lxv v2, 0(r3)
 ; CHECK-NEXT:    addis r3, r2, .LC0@toc@ha
 ; CHECK-NEXT:    ld r3, .LC0@toc@l(r3)
 ; CHECK-NEXT:    lxv v3, 16(r3)
 ; CHECK-NEXT:    xsaddqp v2, v2, v3
 ; CHECK-NEXT:    xscvqpswz v2, v2
 ; CHECK-NEXT:    mfvsrwz r3, v2
-; CHECK-NEXT:    extsw r3, r3
+; CHECK-NEXT:    extsb r3, r3
 ; CHECK-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: qpConv2sb_03:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    mflr r0
 ; CHECK-P8-NEXT:    std r0, 16(r1)
 ; CHECK-P8-NEXT:    stdu r1, -32(r1)
 ; CHECK-P8-NEXT:    .cfi_def_cfa_offset 32
 ; CHECK-P8-NEXT:    .cfi_offset lr, 16
 ; CHECK-P8-NEXT:    addis r4, r2, .LC0@toc@ha
 ; CHECK-P8-NEXT:    lvx v2, 0, r3
 ; CHECK-P8-NEXT:    ld r4, .LC0@toc@l(r4)
 ; CHECK-P8-NEXT:    addi r4, r4, 16
 ; CHECK-P8-NEXT:    lvx v3, 0, r4
 ; CHECK-P8-NEXT:    bl __addkf3
 ; CHECK-P8-NEXT:    nop
 ; CHECK-P8-NEXT:    bl __fixkfsi
 ; CHECK-P8-NEXT:    nop
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsb r3, r3
 ; CHECK-P8-NEXT:    addi r1, r1, 32
 ; CHECK-P8-NEXT:    ld r0, 16(r1)
 ; CHECK-P8-NEXT:    mtlr r0
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = load fp128, fp128* %a, align 16
   %1 = load fp128, fp128* getelementptr inbounds
                             ([4 x fp128], [4 x fp128]* @f128Array,

 
 ; Function Attrs: norecurse nounwind readonly
 define zeroext i8 @qpConv2ub(fp128* nocapture readonly %a) {
 ; CHECK-LABEL: qpConv2ub:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lxv v2, 0(r3)
 ; CHECK-NEXT:    xscvqpswz v2, v2
 ; CHECK-NEXT:    mfvsrwz r3, v2
-; CHECK-NEXT:    clrldi r3, r3, 32
+; CHECK-NEXT:    clrldi r3, r3, 56
 ; CHECK-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: qpConv2ub:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    mflr r0
 ; CHECK-P8-NEXT:    std r0, 16(r1)
 ; CHECK-P8-NEXT:    stdu r1, -32(r1)
 ; CHECK-P8-NEXT:    .cfi_def_cfa_offset 32
 ; CHECK-P8-NEXT:    .cfi_offset lr, 16
 ; CHECK-P8-NEXT:    lvx v2, 0, r3
 ; CHECK-P8-NEXT:    bl __fixkfsi
 ; CHECK-P8-NEXT:    nop
+; CHECK-P8-NEXT:    clrldi r3, r3, 56
 ; CHECK-P8-NEXT:    addi r1, r1, 32
 ; CHECK-P8-NEXT:    ld r0, 16(r1)
 ; CHECK-P8-NEXT:    mtlr r0
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = load fp128, fp128* %a, align 16
   %conv = fptoui fp128 %0 to i8
   ret i8 %conv

 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lxv v2, 0(r3)
 ; CHECK-NEXT:    addis r3, r2, .LC0@toc@ha
 ; CHECK-NEXT:    ld r3, .LC0@toc@l(r3)
 ; CHECK-NEXT:    lxv v3, 16(r3)
 ; CHECK-NEXT:    xsaddqp v2, v2, v3
 ; CHECK-NEXT:    xscvqpswz v2, v2
 ; CHECK-NEXT:    mfvsrwz r3, v2
-; CHECK-NEXT:    clrldi r3, r3, 32
+; CHECK-NEXT:    clrldi r3, r3, 56
 ; CHECK-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: qpConv2ub_03:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    mflr r0
 ; CHECK-P8-NEXT:    std r0, 16(r1)
 ; CHECK-P8-NEXT:    stdu r1, -32(r1)
 ; CHECK-P8-NEXT:    .cfi_def_cfa_offset 32
 ; CHECK-P8-NEXT:    .cfi_offset lr, 16
 ; CHECK-P8-NEXT:    addis r4, r2, .LC0@toc@ha
 ; CHECK-P8-NEXT:    lvx v2, 0, r3
 ; CHECK-P8-NEXT:    ld r4, .LC0@toc@l(r4)
 ; CHECK-P8-NEXT:    addi r4, r4, 16
 ; CHECK-P8-NEXT:    lvx v3, 0, r4
 ; CHECK-P8-NEXT:    bl __addkf3
 ; CHECK-P8-NEXT:    nop
 ; CHECK-P8-NEXT:    bl __fixkfsi
 ; CHECK-P8-NEXT:    nop
+; CHECK-P8-NEXT:    clrldi r3, r3, 56
 ; CHECK-P8-NEXT:    addi r1, r1, 32
 ; CHECK-P8-NEXT:    ld r0, 16(r1)
 ; CHECK-P8-NEXT:    mtlr r0
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = load fp128, fp128* %a, align 16
   %1 = load fp128, fp128* getelementptr inbounds
                             ([4 x fp128], [4 x fp128]* @f128Array,

llvm/test/CodeGen/PowerPC/fp-int-conversions-direct-moves.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc -verify-machineinstrs -mcpu=pwr8 -ppc-asm-full-reg-names \
 ; RUN:     -ppc-vsr-nums-as-vr -mtriple=powerpc64-unknown-unknown < %s | FileCheck %s
 ; RUN: llc -verify-machineinstrs -mcpu=pwr8 -ppc-asm-full-reg-names \
 ; RUN:     -ppc-vsr-nums-as-vr -mtriple=powerpc64le-unknown-unknown < %s | FileCheck %s
 
 ; Function Attrs: nounwind
 define zeroext i8 @_Z6testcff(float %arg) {
 ; CHECK-LABEL: _Z6testcff:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    xscvdpsxws f0, f1
 ; CHECK-NEXT:    stfs f1, -4(r1)
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    clrldi r3, r3, 32
+; CHECK-NEXT:    clrldi r3, r3, 56
 ; CHECK-NEXT:    blr
 entry:
   %arg.addr = alloca float, align 4
   store float %arg, float* %arg.addr, align 4
   %0 = load float, float* %arg.addr, align 4
   %conv = fptoui float %0 to i8
   ret i8 %conv
 }

 
 ; Function Attrs: nounwind
 define zeroext i8 @_Z6testcdd(double %arg) {
 ; CHECK-LABEL: _Z6testcdd:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    xscvdpsxws f0, f1
 ; CHECK-NEXT:    stfd f1, -8(r1)
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    clrldi r3, r3, 32
+; CHECK-NEXT:    clrldi r3, r3, 56
 ; CHECK-NEXT:    blr
 entry:
   %arg.addr = alloca double, align 8
   store double %arg, double* %arg.addr, align 8
   %0 = load double, double* %arg.addr, align 8
   %conv = fptoui double %0 to i8
   ret i8 %conv
 }

 
 ; Function Attrs: nounwind
 define zeroext i8 @_Z7testucff(float %arg) {
 ; CHECK-LABEL: _Z7testucff:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    xscvdpsxws f0, f1
 ; CHECK-NEXT:    stfs f1, -4(r1)
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    clrldi r3, r3, 32
+; CHECK-NEXT:    clrldi r3, r3, 56
 ; CHECK-NEXT:    blr
 entry:
   %arg.addr = alloca float, align 4
   store float %arg, float* %arg.addr, align 4
   %0 = load float, float* %arg.addr, align 4
   %conv = fptoui float %0 to i8
   ret i8 %conv
 }

 
 ; Function Attrs: nounwind
 define zeroext i8 @_Z7testucdd(double %arg) {
 ; CHECK-LABEL: _Z7testucdd:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    xscvdpsxws f0, f1
 ; CHECK-NEXT:    stfd f1, -8(r1)
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    clrldi r3, r3, 32
+; CHECK-NEXT:    clrldi r3, r3, 56
 ; CHECK-NEXT:    blr
 entry:
   %arg.addr = alloca double, align 8
   store double %arg, double* %arg.addr, align 8
   %0 = load double, double* %arg.addr, align 8
   %conv = fptoui double %0 to i8
   ret i8 %conv
 }

 
 ; Function Attrs: nounwind
 define signext i16 @_Z6testsff(float %arg) {
 ; CHECK-LABEL: _Z6testsff:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    xscvdpsxws f0, f1
 ; CHECK-NEXT:    stfs f1, -4(r1)
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    extsw r3, r3
+; CHECK-NEXT:    extsh r3, r3
 ; CHECK-NEXT:    blr
 entry:
   %arg.addr = alloca float, align 4
   store float %arg, float* %arg.addr, align 4
   %0 = load float, float* %arg.addr, align 4
   %conv = fptosi float %0 to i16
   ret i16 %conv
 }

 
 ; Function Attrs: nounwind
 define signext i16 @_Z6testsdd(double %arg) {
 ; CHECK-LABEL: _Z6testsdd:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    xscvdpsxws f0, f1
 ; CHECK-NEXT:    stfd f1, -8(r1)
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    extsw r3, r3
+; CHECK-NEXT:    extsh r3, r3
 ; CHECK-NEXT:    blr
 entry:
   %arg.addr = alloca double, align 8
   store double %arg, double* %arg.addr, align 8
   %0 = load double, double* %arg.addr, align 8
   %conv = fptosi double %0 to i16
   ret i16 %conv
 }

 
 ; Function Attrs: nounwind
 define zeroext i16 @_Z7testusff(float %arg) {
 ; CHECK-LABEL: _Z7testusff:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    xscvdpsxws f0, f1
 ; CHECK-NEXT:    stfs f1, -4(r1)
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    clrldi r3, r3, 32
+; CHECK-NEXT:    clrldi r3, r3, 48
 ; CHECK-NEXT:    blr
 entry:
   %arg.addr = alloca float, align 4
   store float %arg, float* %arg.addr, align 4
   %0 = load float, float* %arg.addr, align 4
   %conv = fptoui float %0 to i16
   ret i16 %conv
 }

 
 ; Function Attrs: nounwind
 define zeroext i16 @_Z7testusdd(double %arg) {
 ; CHECK-LABEL: _Z7testusdd:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    xscvdpsxws f0, f1
 ; CHECK-NEXT:    stfd f1, -8(r1)
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    clrldi r3, r3, 32
+; CHECK-NEXT:    clrldi r3, r3, 48
 ; CHECK-NEXT:    blr
 entry:
   %arg.addr = alloca double, align 8
   store double %arg, double* %arg.addr, align 8
   %0 = load double, double* %arg.addr, align 8
   %conv = fptoui double %0 to i16
   ret i16 %conv
 }

llvm/test/CodeGen/PowerPC/fp64-to-int16.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc -O0 < %s | FileCheck %s
 target triple = "powerpc64le--linux-gnu"
 
 define i1 @Test(double %a) {
 ; CHECK-LABEL: Test:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    xscvdpsxws 0, 1
 ; CHECK-NEXT:    mffprwz 3, 0
+; CHECK-NEXT:    clrlwi 3, 3, 16
 ; CHECK-NEXT:    xori 3, 3, 65534
 ; CHECK-NEXT:    cntlzw 3, 3
 ; CHECK-NEXT:    srwi 4, 3, 5
 ; CHECK-NEXT:    # implicit-def: $x3
 ; CHECK-NEXT:    mr 3, 4
 ; CHECK-NEXT:    blr
 entry:
   %conv = fptoui double %a to i16
   %cmp = icmp eq i16 %conv, -2
   ret i1 %cmp
 }

llvm/test/CodeGen/PowerPC/pr47660.ll

 ; CHECK-LE:       # %bb.0: # %entry
 ; CHECK-LE-NEXT:    clrlwi r3, r3, 24
 ; CHECK-LE-NEXT:    xxlxor f1, f1, f1
 ; CHECK-LE-NEXT:    mtfprwz f0, r3
 ; CHECK-LE-NEXT:    xscvuxddp f0, f0
 ; CHECK-LE-NEXT:    xsmuldp f0, f0, f1
 ; CHECK-LE-NEXT:    xscvdpsxws f0, f0
 ; CHECK-LE-NEXT:    mffprwz r3, f0
-; CHECK-LE-NEXT:    clrldi r3, r3, 32
+; CHECK-LE-NEXT:    clrldi r3, r3, 56
 ; CHECK-LE-NEXT:    blr
 ;
 ; CHECK-BE-LABEL: _Z1f1c:
 ; CHECK-BE:       # %bb.0: # %entry
 ; CHECK-BE-NEXT:    clrldi r3, r3, 56
 ; CHECK-BE-NEXT:    std r3, -16(r1)
 ; CHECK-BE-NEXT:    addis r3, r2, .LCPI0_0@toc@ha
 ; CHECK-BE-NEXT:    lfd f0, -16(r1)
 ; CHECK-BE-NEXT:    lfs f1, .LCPI0_0@toc@l(r3)
 ; CHECK-BE-NEXT:    fcfid f0, f0
 ; CHECK-BE-NEXT:    fmul f0, f0, f1
 ; CHECK-BE-NEXT:    fctiwz f0, f0
 ; CHECK-BE-NEXT:    stfd f0, -8(r1)
-; CHECK-BE-NEXT:    lwz r3, -4(r1)
-; CHECK-BE-NEXT:    clrldi r3, r3, 32
+; CHECK-BE-NEXT:    lbz r3, -1(r1)
 ; CHECK-BE-NEXT:    blr
 entry:
   %0 = and i24 %g.coerce, 255
   %conv1 = uitofp i24 %0 to double
   %mul = fmul double 0.000000e+00, %conv1
   %conv2 = fptoui double %mul to i8
   %retval.sroa.0.0.insert.ext = zext i8 %conv2 to i24
   ret i24 %retval.sroa.0.0.insert.ext
 }
 
 attributes #0 = { "use-soft-float"="false" }

llvm/test/CodeGen/PowerPC/scalar-i16-ldst.ll

 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i16 @ld_0_int16_t_float(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_0_int16_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    lfs f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsh r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_0_int16_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lfs f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsh r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_0_int16_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsh r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = inttoptr i64 %ptr to float*
   %1 = load float, float* %0, align 4
   %conv = fptosi float %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i16 @ld_align16_int16_t_float(i8* nocapture readonly %ptr) {
 ; CHECK-LABEL: ld_align16_int16_t_float:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lfs f0, 8(r3)
 ; CHECK-NEXT:    xscvdpsxws f0, f0
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    extsw r3, r3
+; CHECK-NEXT:    extsh r3, r3
 ; CHECK-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 8
   %0 = bitcast i8* %add.ptr to float*
   %1 = load float, float* %0, align 4
   %conv = fptosi float %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i16 @ld_align32_int16_t_float(i8* nocapture readonly %ptr) {
 ; CHECK-P10-LABEL: ld_align32_int16_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 99999000
 ; CHECK-P10-NEXT:    lfsx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsh r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-PREP10-LABEL: ld_align32_int16_t_float:
 ; CHECK-PREP10:       # %bb.0: # %entry
 ; CHECK-PREP10-NEXT:    lis r4, 1525
 ; CHECK-PREP10-NEXT:    ori r4, r4, 56600
 ; CHECK-PREP10-NEXT:    lfsx f0, r3, r4
 ; CHECK-PREP10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-PREP10-NEXT:    mffprwz r3, f0
-; CHECK-PREP10-NEXT:    extsw r3, r3
+; CHECK-PREP10-NEXT:    extsh r3, r3
 ; CHECK-PREP10-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 99999000
   %0 = bitcast i8* %add.ptr to float*
   %1 = load float, float* %0, align 4
   %conv = fptosi float %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i16 @ld_align64_int16_t_float(i8* nocapture readonly %ptr) {
 ; CHECK-P10-LABEL: ld_align64_int16_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 244140625
 ; CHECK-P10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-P10-NEXT:    lfsx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsh r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-PREP10-LABEL: ld_align64_int16_t_float:
 ; CHECK-PREP10:       # %bb.0: # %entry
 ; CHECK-PREP10-NEXT:    lis r4, 3725
 ; CHECK-PREP10-NEXT:    ori r4, r4, 19025
 ; CHECK-PREP10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-PREP10-NEXT:    lfsx f0, r3, r4
 ; CHECK-PREP10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-PREP10-NEXT:    mffprwz r3, f0
-; CHECK-PREP10-NEXT:    extsw r3, r3
+; CHECK-PREP10-NEXT:    extsh r3, r3
 ; CHECK-PREP10-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 1000000000000
   %0 = bitcast i8* %add.ptr to float*
   %1 = load float, float* %0, align 4
   %conv = fptosi float %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i16 @ld_reg_int16_t_float(i8* nocapture readonly %ptr, i64 %off) {
 ; CHECK-LABEL: ld_reg_int16_t_float:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lfsx f0, r3, r4
 ; CHECK-NEXT:    xscvdpsxws f0, f0
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    extsw r3, r3
+; CHECK-NEXT:    extsh r3, r3
 ; CHECK-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 %off
   %0 = bitcast i8* %add.ptr to float*
   %1 = load float, float* %0, align 4
   %conv = fptosi float %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i16 @ld_or_int16_t_float(i64 %ptr, i8 zeroext %off) {
 ; CHECK-P10-LABEL: ld_or_int16_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    or r3, r4, r3
 ; CHECK-P10-NEXT:    lfs f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsh r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_or_int16_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    or r3, r4, r3
 ; CHECK-P9-NEXT:    lfs f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsh r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_or_int16_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    or r3, r4, r3
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsh r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %conv = zext i8 %off to i64
   %or = or i64 %conv, %ptr
   %0 = inttoptr i64 %or to float*
   %1 = load float, float* %0, align 4
   %conv1 = fptosi float %1 to i16
   ret i16 %conv1
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i16 @ld_not_disjoint16_int16_t_float(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_not_disjoint16_int16_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    ori r3, r3, 6
 ; CHECK-P10-NEXT:    lfs f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsh r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_not_disjoint16_int16_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    ori r3, r3, 6
 ; CHECK-P9-NEXT:    lfs f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsh r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_not_disjoint16_int16_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    ori r3, r3, 6
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsh r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %or = or i64 %ptr, 6
   %0 = inttoptr i64 %or to float*
   %1 = load float, float* %0, align 4
   %conv = fptosi float %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i16 @ld_disjoint_align16_int16_t_float(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_disjoint_align16_int16_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    rldicr r3, r3, 0, 51
 ; CHECK-P10-NEXT:    lfs f0, 24(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsh r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_disjoint_align16_int16_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    rldicr r3, r3, 0, 51
 ; CHECK-P9-NEXT:    lfs f0, 24(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsh r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_disjoint_align16_int16_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    rldicr r3, r3, 0, 51
 ; CHECK-P8-NEXT:    ori r3, r3, 24
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsh r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %and = and i64 %ptr, -4096
   %or = or i64 %and, 24
   %0 = inttoptr i64 %or to float*
   %1 = load float, float* %0, align 8
   %conv = fptosi float %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i16 @ld_not_disjoint32_int16_t_float(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_not_disjoint32_int16_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    ori r3, r3, 34463
 ; CHECK-P10-NEXT:    oris r3, r3, 1
 ; CHECK-P10-NEXT:    lfs f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsh r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_not_disjoint32_int16_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    ori r3, r3, 34463
 ; CHECK-P9-NEXT:    oris r3, r3, 1
 ; CHECK-P9-NEXT:    lfs f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsh r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_not_disjoint32_int16_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    ori r3, r3, 34463
 ; CHECK-P8-NEXT:    oris r3, r3, 1
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsh r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %or = or i64 %ptr, 99999
   %0 = inttoptr i64 %or to float*
   %1 = load float, float* %0, align 4
   %conv = fptosi float %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i16 @ld_disjoint_align32_int16_t_float(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_disjoint_align32_int16_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    lis r4, -15264
 ; CHECK-P10-NEXT:    and r3, r3, r4
 ; CHECK-P10-NEXT:    pli r4, 999990000
 ; CHECK-P10-NEXT:    lfsx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsh r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_disjoint_align32_int16_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lis r4, -15264
 ; CHECK-P9-NEXT:    and r3, r3, r4
 ; CHECK-P9-NEXT:    lis r4, 15258
 ; CHECK-P9-NEXT:    ori r4, r4, 41712
 ; CHECK-P9-NEXT:    lfsx f0, r3, r4
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsh r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_disjoint_align32_int16_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lis r4, -15264
 ; CHECK-P8-NEXT:    lis r5, 15258
 ; CHECK-P8-NEXT:    and r3, r3, r4
 ; CHECK-P8-NEXT:    ori r4, r5, 41712
 ; CHECK-P8-NEXT:    lfsx f0, r3, r4
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsh r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %and = and i64 %ptr, -1000341504
   %or = or i64 %and, 999990000
   %0 = inttoptr i64 %or to float*
   %1 = load float, float* %0, align 16
   %conv = fptosi float %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i16 @ld_not_disjoint64_int16_t_float(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_not_disjoint64_int16_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 232
 ; CHECK-P10-NEXT:    pli r5, 3567587329
 ; CHECK-P10-NEXT:    rldimi r5, r4, 32, 0
 ; CHECK-P10-NEXT:    or r3, r3, r5
 ; CHECK-P10-NEXT:    lfs f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsh r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_not_disjoint64_int16_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    li r4, 29
 ; CHECK-P9-NEXT:    rldic r4, r4, 35, 24
 ; CHECK-P9-NEXT:    oris r4, r4, 54437
 ; CHECK-P9-NEXT:    ori r4, r4, 4097
 ; CHECK-P9-NEXT:    or r3, r3, r4
 ; CHECK-P9-NEXT:    lfs f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsh r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_not_disjoint64_int16_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    li r4, 29
 ; CHECK-P8-NEXT:    rldic r4, r4, 35, 24
 ; CHECK-P8-NEXT:    oris r4, r4, 54437
 ; CHECK-P8-NEXT:    ori r4, r4, 4097
 ; CHECK-P8-NEXT:    or r3, r3, r4
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsh r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %or = or i64 %ptr, 1000000000001
   %0 = inttoptr i64 %or to float*
   %1 = load float, float* %0, align 4
   %conv = fptosi float %1 to i16
   ret i16 %conv
 }
 
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i16 @ld_disjoint_align64_int16_t_float(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_disjoint_align64_int16_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 244140625
 ; CHECK-P10-NEXT:    rldicr r3, r3, 0, 23
 ; CHECK-P10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-P10-NEXT:    lfsx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsh r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-PREP10-LABEL: ld_disjoint_align64_int16_t_float:
 ; CHECK-PREP10:       # %bb.0: # %entry
 ; CHECK-PREP10-NEXT:    lis r4, 3725
 ; CHECK-PREP10-NEXT:    rldicr r3, r3, 0, 23
 ; CHECK-PREP10-NEXT:    ori r4, r4, 19025
 ; CHECK-PREP10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-PREP10-NEXT:    lfsx f0, r3, r4
 ; CHECK-PREP10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-PREP10-NEXT:    mffprwz r3, f0
-; CHECK-PREP10-NEXT:    extsw r3, r3
+; CHECK-PREP10-NEXT:    extsh r3, r3
 ; CHECK-PREP10-NEXT:    blr
 entry:
   %and = and i64 %ptr, -1099511627776
   %or = or i64 %and, 1000000000000
   %0 = inttoptr i64 %or to float*
   %1 = load float, float* %0, align 4096
   %conv = fptosi float %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i16 @ld_cst_align16_int16_t_float() {
 ; CHECK-LABEL: ld_cst_align16_int16_t_float:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lfs f0, 4080(0)
 ; CHECK-NEXT:    xscvdpsxws f0, f0
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    extsw r3, r3
+; CHECK-NEXT:    extsh r3, r3
 ; CHECK-NEXT:    blr
 entry:
   %0 = load float, float* inttoptr (i64 4080 to float*), align 16
   %conv = fptosi float %0 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i16 @ld_cst_align32_int16_t_float() {
 ; CHECK-P10-LABEL: ld_cst_align32_int16_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    lis r3, 153
 ; CHECK-P10-NEXT:    lfs f0, -27108(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsh r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_cst_align32_int16_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lis r3, 153
 ; CHECK-P9-NEXT:    lfs f0, -27108(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsh r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_cst_align32_int16_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lis r3, 152
 ; CHECK-P8-NEXT:    ori r3, r3, 38428
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsh r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = load float, float* inttoptr (i64 9999900 to float*), align 4
   %conv = fptosi float %0 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i16 @ld_cst_align64_int16_t_float() {
 ; CHECK-P10-LABEL: ld_cst_align64_int16_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r3, 244140625
 ; CHECK-P10-NEXT:    rldic r3, r3, 12, 24
 ; CHECK-P10-NEXT:    lfs f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsh r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_cst_align64_int16_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lis r3, 3725
 ; CHECK-P9-NEXT:    ori r3, r3, 19025
 ; CHECK-P9-NEXT:    rldic r3, r3, 12, 24
 ; CHECK-P9-NEXT:    lfs f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsh r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_cst_align64_int16_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lis r3, 3725
 ; CHECK-P8-NEXT:    ori r3, r3, 19025
 ; CHECK-P8-NEXT:    rldic r3, r3, 12, 24
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsh r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = load float, float* inttoptr (i64 1000000000000 to float*), align 4096
   %conv = fptosi float %0 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i16 @ld_0_int16_t_double(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_0_int16_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    lfd f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsh r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_0_int16_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lfd f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsh r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_0_int16_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsh r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = inttoptr i64 %ptr to double*
   %1 = load double, double* %0, align 8
   %conv = fptosi double %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i16 @ld_align16_int16_t_double(i8* nocapture readonly %ptr) {
 ; CHECK-LABEL: ld_align16_int16_t_double:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lfd f0, 8(r3)
 ; CHECK-NEXT:    xscvdpsxws f0, f0
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    extsw r3, r3
+; CHECK-NEXT:    extsh r3, r3
 ; CHECK-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 8
   %0 = bitcast i8* %add.ptr to double*
   %1 = load double, double* %0, align 8
   %conv = fptosi double %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i16 @ld_align32_int16_t_double(i8* nocapture readonly %ptr) {
 ; CHECK-P10-LABEL: ld_align32_int16_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 99999000
 ; CHECK-P10-NEXT:    lfdx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsh r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-PREP10-LABEL: ld_align32_int16_t_double:
 ; CHECK-PREP10:       # %bb.0: # %entry
 ; CHECK-PREP10-NEXT:    lis r4, 1525
 ; CHECK-PREP10-NEXT:    ori r4, r4, 56600
 ; CHECK-PREP10-NEXT:    lfdx f0, r3, r4
 ; CHECK-PREP10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-PREP10-NEXT:    mffprwz r3, f0
-; CHECK-PREP10-NEXT:    extsw r3, r3
+; CHECK-PREP10-NEXT:    extsh r3, r3
 ; CHECK-PREP10-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 99999000
   %0 = bitcast i8* %add.ptr to double*
   %1 = load double, double* %0, align 8
   %conv = fptosi double %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i16 @ld_align64_int16_t_double(i8* nocapture readonly %ptr) {
 ; CHECK-P10-LABEL: ld_align64_int16_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 244140625
 ; CHECK-P10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-P10-NEXT:    lfdx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsh r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-PREP10-LABEL: ld_align64_int16_t_double:
 ; CHECK-PREP10:       # %bb.0: # %entry
 ; CHECK-PREP10-NEXT:    lis r4, 3725
 ; CHECK-PREP10-NEXT:    ori r4, r4, 19025
 ; CHECK-PREP10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-PREP10-NEXT:    lfdx f0, r3, r4
 ; CHECK-PREP10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-PREP10-NEXT:    mffprwz r3, f0
-; CHECK-PREP10-NEXT:    extsw r3, r3
+; CHECK-PREP10-NEXT:    extsh r3, r3
 ; CHECK-PREP10-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 1000000000000
   %0 = bitcast i8* %add.ptr to double*
   %1 = load double, double* %0, align 8
   %conv = fptosi double %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i16 @ld_reg_int16_t_double(i8* nocapture readonly %ptr, i64 %off) {
 ; CHECK-LABEL: ld_reg_int16_t_double:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lfdx f0, r3, r4
 ; CHECK-NEXT:    xscvdpsxws f0, f0
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    extsw r3, r3
+; CHECK-NEXT:    extsh r3, r3
 ; CHECK-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 %off
   %0 = bitcast i8* %add.ptr to double*
   %1 = load double, double* %0, align 8
   %conv = fptosi double %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i16 @ld_or_int16_t_double(i64 %ptr, i8 zeroext %off) {
 ; CHECK-P10-LABEL: ld_or_int16_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    or r3, r4, r3
 ; CHECK-P10-NEXT:    lfd f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsh r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_or_int16_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    or r3, r4, r3
 ; CHECK-P9-NEXT:    lfd f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsh r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_or_int16_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    or r3, r4, r3
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsh r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %conv = zext i8 %off to i64
   %or = or i64 %conv, %ptr
   %0 = inttoptr i64 %or to double*
   %1 = load double, double* %0, align 8
   %conv1 = fptosi double %1 to i16
   ret i16 %conv1
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i16 @ld_not_disjoint16_int16_t_double(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_not_disjoint16_int16_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    ori r3, r3, 6
 ; CHECK-P10-NEXT:    lfd f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsh r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_not_disjoint16_int16_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    ori r3, r3, 6
 ; CHECK-P9-NEXT:    lfd f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsh r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_not_disjoint16_int16_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    ori r3, r3, 6
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsh r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %or = or i64 %ptr, 6
   %0 = inttoptr i64 %or to double*
   %1 = load double, double* %0, align 8
   %conv = fptosi double %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i16 @ld_disjoint_align16_int16_t_double(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_disjoint_align16_int16_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    rldicr r3, r3, 0, 51
 ; CHECK-P10-NEXT:    lfd f0, 24(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsh r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_disjoint_align16_int16_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    rldicr r3, r3, 0, 51
 ; CHECK-P9-NEXT:    lfd f0, 24(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsh r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_disjoint_align16_int16_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    rldicr r3, r3, 0, 51
 ; CHECK-P8-NEXT:    ori r3, r3, 24
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsh r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %and = and i64 %ptr, -4096
   %or = or i64 %and, 24
   %0 = inttoptr i64 %or to double*
   %1 = load double, double* %0, align 8
   %conv = fptosi double %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i16 @ld_not_disjoint32_int16_t_double(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_not_disjoint32_int16_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    ori r3, r3, 34463
 ; CHECK-P10-NEXT:    oris r3, r3, 1
 ; CHECK-P10-NEXT:    lfd f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsh r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_not_disjoint32_int16_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    ori r3, r3, 34463
 ; CHECK-P9-NEXT:    oris r3, r3, 1
 ; CHECK-P9-NEXT:    lfd f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsh r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_not_disjoint32_int16_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    ori r3, r3, 34463
 ; CHECK-P8-NEXT:    oris r3, r3, 1
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsh r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %or = or i64 %ptr, 99999
   %0 = inttoptr i64 %or to double*
   %1 = load double, double* %0, align 8
   %conv = fptosi double %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i16 @ld_disjoint_align32_int16_t_double(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_disjoint_align32_int16_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    lis r4, -15264
 ; CHECK-P10-NEXT:    and r3, r3, r4
 ; CHECK-P10-NEXT:    pli r4, 999990000
 ; CHECK-P10-NEXT:    lfdx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsh r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_disjoint_align32_int16_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lis r4, -15264
 ; CHECK-P9-NEXT:    and r3, r3, r4
 ; CHECK-P9-NEXT:    lis r4, 15258
 ; CHECK-P9-NEXT:    ori r4, r4, 41712
 ; CHECK-P9-NEXT:    lfdx f0, r3, r4
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsh r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_disjoint_align32_int16_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lis r4, -15264
 ; CHECK-P8-NEXT:    lis r5, 15258
 ; CHECK-P8-NEXT:    and r3, r3, r4
 ; CHECK-P8-NEXT:    ori r4, r5, 41712
 ; CHECK-P8-NEXT:    lfdx f0, r3, r4
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsh r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %and = and i64 %ptr, -1000341504
   %or = or i64 %and, 999990000
   %0 = inttoptr i64 %or to double*
   %1 = load double, double* %0, align 16
   %conv = fptosi double %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i16 @ld_not_disjoint64_int16_t_double(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_not_disjoint64_int16_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 232
 ; CHECK-P10-NEXT:    pli r5, 3567587329
 ; CHECK-P10-NEXT:    rldimi r5, r4, 32, 0
 ; CHECK-P10-NEXT:    or r3, r3, r5
 ; CHECK-P10-NEXT:    lfd f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsh r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_not_disjoint64_int16_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    li r4, 29
 ; CHECK-P9-NEXT:    rldic r4, r4, 35, 24
 ; CHECK-P9-NEXT:    oris r4, r4, 54437
 ; CHECK-P9-NEXT:    ori r4, r4, 4097
 ; CHECK-P9-NEXT:    or r3, r3, r4
 ; CHECK-P9-NEXT:    lfd f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsh r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_not_disjoint64_int16_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    li r4, 29
 ; CHECK-P8-NEXT:    rldic r4, r4, 35, 24
 ; CHECK-P8-NEXT:    oris r4, r4, 54437
 ; CHECK-P8-NEXT:    ori r4, r4, 4097
 ; CHECK-P8-NEXT:    or r3, r3, r4
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsh r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %or = or i64 %ptr, 1000000000001
   %0 = inttoptr i64 %or to double*
   %1 = load double, double* %0, align 8
   %conv = fptosi double %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i16 @ld_disjoint_align64_int16_t_double(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_disjoint_align64_int16_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 244140625
 ; CHECK-P10-NEXT:    rldicr r3, r3, 0, 23
 ; CHECK-P10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-P10-NEXT:    lfdx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsh r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-PREP10-LABEL: ld_disjoint_align64_int16_t_double:
 ; CHECK-PREP10:       # %bb.0: # %entry
 ; CHECK-PREP10-NEXT:    lis r4, 3725
 ; CHECK-PREP10-NEXT:    rldicr r3, r3, 0, 23
 ; CHECK-PREP10-NEXT:    ori r4, r4, 19025
 ; CHECK-PREP10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-PREP10-NEXT:    lfdx f0, r3, r4
 ; CHECK-PREP10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-PREP10-NEXT:    mffprwz r3, f0
-; CHECK-PREP10-NEXT:    extsw r3, r3
+; CHECK-PREP10-NEXT:    extsh r3, r3
 ; CHECK-PREP10-NEXT:    blr
 entry:
   %and = and i64 %ptr, -1099511627776
   %or = or i64 %and, 1000000000000
   %0 = inttoptr i64 %or to double*
   %1 = load double, double* %0, align 4096
   %conv = fptosi double %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i16 @ld_cst_align16_int16_t_double() {
 ; CHECK-LABEL: ld_cst_align16_int16_t_double:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lfd f0, 4080(0)
 ; CHECK-NEXT:    xscvdpsxws f0, f0
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    extsw r3, r3
+; CHECK-NEXT:    extsh r3, r3
 ; CHECK-NEXT:    blr
 entry:
   %0 = load double, double* inttoptr (i64 4080 to double*), align 16
   %conv = fptosi double %0 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i16 @ld_cst_align32_int16_t_double() {
 ; CHECK-P10-LABEL: ld_cst_align32_int16_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    lis r3, 153
 ; CHECK-P10-NEXT:    lfd f0, -27108(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsh r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_cst_align32_int16_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lis r3, 153
 ; CHECK-P9-NEXT:    lfd f0, -27108(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsh r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_cst_align32_int16_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lis r3, 152
 ; CHECK-P8-NEXT:    ori r3, r3, 38428
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsh r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = load double, double* inttoptr (i64 9999900 to double*), align 8
   %conv = fptosi double %0 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i16 @ld_cst_align64_int16_t_double() {
 ; CHECK-P10-LABEL: ld_cst_align64_int16_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r3, 244140625
 ; CHECK-P10-NEXT:    rldic r3, r3, 12, 24
 ; CHECK-P10-NEXT:    lfd f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsh r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_cst_align64_int16_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lis r3, 3725
 ; CHECK-P9-NEXT:    ori r3, r3, 19025
 ; CHECK-P9-NEXT:    rldic r3, r3, 12, 24
 ; CHECK-P9-NEXT:    lfd f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsh r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_cst_align64_int16_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lis r3, 3725
 ; CHECK-P8-NEXT:    ori r3, r3, 19025
 ; CHECK-P8-NEXT:    rldic r3, r3, 12, 24
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsh r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = load double, double* inttoptr (i64 1000000000000 to double*), align 4096
   %conv = fptosi double %0 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn

 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i16 @ld_align16_uint16_t_float(i8* nocapture readonly %ptr) {
 ; CHECK-LABEL: ld_align16_uint16_t_float:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lfs f0, 8(r3)
 ; CHECK-NEXT:    xscvdpsxws f0, f0
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    clrldi r3, r3, 32
+; CHECK-NEXT:    clrldi r3, r3, 48
 ; CHECK-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 8
   %0 = bitcast i8* %add.ptr to float*
   %1 = load float, float* %0, align 4
   %conv = fptoui float %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i16 @ld_align32_uint16_t_float(i8* nocapture readonly %ptr) {
 ; CHECK-P10-LABEL: ld_align32_uint16_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 99999000
 ; CHECK-P10-NEXT:    lfsx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 48
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-PREP10-LABEL: ld_align32_uint16_t_float:
 ; CHECK-PREP10:       # %bb.0: # %entry
 ; CHECK-PREP10-NEXT:    lis r4, 1525
 ; CHECK-PREP10-NEXT:    ori r4, r4, 56600
 ; CHECK-PREP10-NEXT:    lfsx f0, r3, r4
 ; CHECK-PREP10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-PREP10-NEXT:    mffprwz r3, f0
-; CHECK-PREP10-NEXT:    clrldi r3, r3, 32
+; CHECK-PREP10-NEXT:    clrldi r3, r3, 48
 ; CHECK-PREP10-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 99999000
   %0 = bitcast i8* %add.ptr to float*
   %1 = load float, float* %0, align 4
   %conv = fptoui float %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i16 @ld_align64_uint16_t_float(i8* nocapture readonly %ptr) {
 ; CHECK-P10-LABEL: ld_align64_uint16_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 244140625
 ; CHECK-P10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-P10-NEXT:    lfsx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 48
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-PREP10-LABEL: ld_align64_uint16_t_float:
 ; CHECK-PREP10:       # %bb.0: # %entry
 ; CHECK-PREP10-NEXT:    lis r4, 3725
 ; CHECK-PREP10-NEXT:    ori r4, r4, 19025
 ; CHECK-PREP10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-PREP10-NEXT:    lfsx f0, r3, r4
 ; CHECK-PREP10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-PREP10-NEXT:    mffprwz r3, f0
-; CHECK-PREP10-NEXT:    clrldi r3, r3, 32
+; CHECK-PREP10-NEXT:    clrldi r3, r3, 48
 ; CHECK-PREP10-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 1000000000000
   %0 = bitcast i8* %add.ptr to float*
   %1 = load float, float* %0, align 4
   %conv = fptoui float %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i16 @ld_reg_uint16_t_float(i8* nocapture readonly %ptr, i64 %off) {
 ; CHECK-LABEL: ld_reg_uint16_t_float:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lfsx f0, r3, r4
 ; CHECK-NEXT:    xscvdpsxws f0, f0
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    clrldi r3, r3, 32
+; CHECK-NEXT:    clrldi r3, r3, 48
 ; CHECK-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 %off
   %0 = bitcast i8* %add.ptr to float*
   %1 = load float, float* %0, align 4
   %conv = fptoui float %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i16 @ld_or_uint16_t_float(i64 %ptr, i8 zeroext %off) {
 ; CHECK-P10-LABEL: ld_or_uint16_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    or r3, r4, r3
 ; CHECK-P10-NEXT:    lfs f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 48
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_or_uint16_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    or r3, r4, r3
 ; CHECK-P9-NEXT:    lfs f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 48
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_or_uint16_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    or r3, r4, r3
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 48
 ; CHECK-P8-NEXT:    blr
 entry:
   %conv = zext i8 %off to i64
   %or = or i64 %conv, %ptr
   %0 = inttoptr i64 %or to float*
   %1 = load float, float* %0, align 4
   %conv1 = fptoui float %1 to i16
   ret i16 %conv1
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i16 @ld_not_disjoint16_uint16_t_float(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_not_disjoint16_uint16_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    ori r3, r3, 6
 ; CHECK-P10-NEXT:    lfs f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 48
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_not_disjoint16_uint16_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    ori r3, r3, 6
 ; CHECK-P9-NEXT:    lfs f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 48
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_not_disjoint16_uint16_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    ori r3, r3, 6
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 48
 ; CHECK-P8-NEXT:    blr
 entry:
   %or = or i64 %ptr, 6
   %0 = inttoptr i64 %or to float*
   %1 = load float, float* %0, align 4
   %conv = fptoui float %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i16 @ld_disjoint_align16_uint16_t_float(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_disjoint_align16_uint16_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    rldicr r3, r3, 0, 51
 ; CHECK-P10-NEXT:    lfs f0, 24(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 48
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_disjoint_align16_uint16_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    rldicr r3, r3, 0, 51
 ; CHECK-P9-NEXT:    lfs f0, 24(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 48
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_disjoint_align16_uint16_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    rldicr r3, r3, 0, 51
 ; CHECK-P8-NEXT:    ori r3, r3, 24
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 48
 ; CHECK-P8-NEXT:    blr
 entry:
   %and = and i64 %ptr, -4096
   %or = or i64 %and, 24
   %0 = inttoptr i64 %or to float*
   %1 = load float, float* %0, align 8
   %conv = fptoui float %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i16 @ld_not_disjoint32_uint16_t_float(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_not_disjoint32_uint16_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    ori r3, r3, 34463
 ; CHECK-P10-NEXT:    oris r3, r3, 1
 ; CHECK-P10-NEXT:    lfs f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 48
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_not_disjoint32_uint16_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    ori r3, r3, 34463
 ; CHECK-P9-NEXT:    oris r3, r3, 1
 ; CHECK-P9-NEXT:    lfs f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 48
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_not_disjoint32_uint16_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    ori r3, r3, 34463
 ; CHECK-P8-NEXT:    oris r3, r3, 1
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 48
 ; CHECK-P8-NEXT:    blr
 entry:
   %or = or i64 %ptr, 99999
   %0 = inttoptr i64 %or to float*
   %1 = load float, float* %0, align 4
   %conv = fptoui float %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i16 @ld_disjoint_align32_uint16_t_float(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_disjoint_align32_uint16_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    lis r4, -15264
 ; CHECK-P10-NEXT:    and r3, r3, r4
 ; CHECK-P10-NEXT:    pli r4, 999990000
 ; CHECK-P10-NEXT:    lfsx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 48
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_disjoint_align32_uint16_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lis r4, -15264
 ; CHECK-P9-NEXT:    and r3, r3, r4
 ; CHECK-P9-NEXT:    lis r4, 15258
 ; CHECK-P9-NEXT:    ori r4, r4, 41712
 ; CHECK-P9-NEXT:    lfsx f0, r3, r4
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 48
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_disjoint_align32_uint16_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lis r4, -15264
 ; CHECK-P8-NEXT:    lis r5, 15258
 ; CHECK-P8-NEXT:    and r3, r3, r4
 ; CHECK-P8-NEXT:    ori r4, r5, 41712
 ; CHECK-P8-NEXT:    lfsx f0, r3, r4
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 48
 ; CHECK-P8-NEXT:    blr
 entry:
   %and = and i64 %ptr, -1000341504
   %or = or i64 %and, 999990000
   %0 = inttoptr i64 %or to float*
   %1 = load float, float* %0, align 16
   %conv = fptoui float %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i16 @ld_not_disjoint64_uint16_t_float(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_not_disjoint64_uint16_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 232
 ; CHECK-P10-NEXT:    pli r5, 3567587329
 ; CHECK-P10-NEXT:    rldimi r5, r4, 32, 0
 ; CHECK-P10-NEXT:    or r3, r3, r5
 ; CHECK-P10-NEXT:    lfs f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 48
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_not_disjoint64_uint16_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    li r4, 29
 ; CHECK-P9-NEXT:    rldic r4, r4, 35, 24
 ; CHECK-P9-NEXT:    oris r4, r4, 54437
 ; CHECK-P9-NEXT:    ori r4, r4, 4097
 ; CHECK-P9-NEXT:    or r3, r3, r4
 ; CHECK-P9-NEXT:    lfs f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 48
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_not_disjoint64_uint16_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    li r4, 29
 ; CHECK-P8-NEXT:    rldic r4, r4, 35, 24
 ; CHECK-P8-NEXT:    oris r4, r4, 54437
 ; CHECK-P8-NEXT:    ori r4, r4, 4097
 ; CHECK-P8-NEXT:    or r3, r3, r4
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 48
 ; CHECK-P8-NEXT:    blr
 entry:
   %or = or i64 %ptr, 1000000000001
   %0 = inttoptr i64 %or to float*
   %1 = load float, float* %0, align 4
   %conv = fptoui float %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i16 @ld_disjoint_align64_uint16_t_float(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_disjoint_align64_uint16_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 244140625
 ; CHECK-P10-NEXT:    rldicr r3, r3, 0, 23
 ; CHECK-P10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-P10-NEXT:    lfsx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 48
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-PREP10-LABEL: ld_disjoint_align64_uint16_t_float:
 ; CHECK-PREP10:       # %bb.0: # %entry
 ; CHECK-PREP10-NEXT:    lis r4, 3725
 ; CHECK-PREP10-NEXT:    rldicr r3, r3, 0, 23
 ; CHECK-PREP10-NEXT:    ori r4, r4, 19025
 ; CHECK-PREP10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-PREP10-NEXT:    lfsx f0, r3, r4
 ; CHECK-PREP10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-PREP10-NEXT:    mffprwz r3, f0
-; CHECK-PREP10-NEXT:    clrldi r3, r3, 32
+; CHECK-PREP10-NEXT:    clrldi r3, r3, 48
 ; CHECK-PREP10-NEXT:    blr
 entry:
   %and = and i64 %ptr, -1099511627776
   %or = or i64 %and, 1000000000000
   %0 = inttoptr i64 %or to float*
   %1 = load float, float* %0, align 4096
   %conv = fptoui float %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i16 @ld_cst_align16_uint16_t_float() {
 ; CHECK-LABEL: ld_cst_align16_uint16_t_float:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lfs f0, 4080(0)
 ; CHECK-NEXT:    xscvdpsxws f0, f0
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    clrldi r3, r3, 32
+; CHECK-NEXT:    clrldi r3, r3, 48
 ; CHECK-NEXT:    blr
 entry:
   %0 = load float, float* inttoptr (i64 4080 to float*), align 16
   %conv = fptoui float %0 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i16 @ld_cst_align32_uint16_t_float() {
 ; CHECK-P10-LABEL: ld_cst_align32_uint16_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    lis r3, 153
 ; CHECK-P10-NEXT:    lfs f0, -27108(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 48
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_cst_align32_uint16_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lis r3, 153
 ; CHECK-P9-NEXT:    lfs f0, -27108(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 48
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_cst_align32_uint16_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lis r3, 152
 ; CHECK-P8-NEXT:    ori r3, r3, 38428
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 48
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = load float, float* inttoptr (i64 9999900 to float*), align 4
   %conv = fptoui float %0 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i16 @ld_cst_align64_uint16_t_float() {
 ; CHECK-P10-LABEL: ld_cst_align64_uint16_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r3, 244140625
 ; CHECK-P10-NEXT:    rldic r3, r3, 12, 24
 ; CHECK-P10-NEXT:    lfs f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 48
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_cst_align64_uint16_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lis r3, 3725
 ; CHECK-P9-NEXT:    ori r3, r3, 19025
 ; CHECK-P9-NEXT:    rldic r3, r3, 12, 24
 ; CHECK-P9-NEXT:    lfs f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 48
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_cst_align64_uint16_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lis r3, 3725
 ; CHECK-P8-NEXT:    ori r3, r3, 19025
 ; CHECK-P8-NEXT:    rldic r3, r3, 12, 24
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 48
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = load float, float* inttoptr (i64 1000000000000 to float*), align 4096
   %conv = fptoui float %0 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i16 @ld_0_uint16_t_double(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_0_uint16_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    lfd f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 48
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_0_uint16_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lfd f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 48
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_0_uint16_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 48
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = inttoptr i64 %ptr to double*
   %1 = load double, double* %0, align 8
   %conv = fptoui double %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i16 @ld_align16_uint16_t_double(i8* nocapture readonly %ptr) {
 ; CHECK-LABEL: ld_align16_uint16_t_double:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lfd f0, 8(r3)
 ; CHECK-NEXT:    xscvdpsxws f0, f0
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    clrldi r3, r3, 32
+; CHECK-NEXT:    clrldi r3, r3, 48
 ; CHECK-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 8
   %0 = bitcast i8* %add.ptr to double*
   %1 = load double, double* %0, align 8
   %conv = fptoui double %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i16 @ld_align32_uint16_t_double(i8* nocapture readonly %ptr) {
 ; CHECK-P10-LABEL: ld_align32_uint16_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 99999000
 ; CHECK-P10-NEXT:    lfdx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 48
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-PREP10-LABEL: ld_align32_uint16_t_double:
 ; CHECK-PREP10:       # %bb.0: # %entry
 ; CHECK-PREP10-NEXT:    lis r4, 1525
 ; CHECK-PREP10-NEXT:    ori r4, r4, 56600
 ; CHECK-PREP10-NEXT:    lfdx f0, r3, r4
 ; CHECK-PREP10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-PREP10-NEXT:    mffprwz r3, f0
-; CHECK-PREP10-NEXT:    clrldi r3, r3, 32
+; CHECK-PREP10-NEXT:    clrldi r3, r3, 48
 ; CHECK-PREP10-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 99999000
   %0 = bitcast i8* %add.ptr to double*
   %1 = load double, double* %0, align 8
   %conv = fptoui double %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i16 @ld_align64_uint16_t_double(i8* nocapture readonly %ptr) {
 ; CHECK-P10-LABEL: ld_align64_uint16_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 244140625
 ; CHECK-P10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-P10-NEXT:    lfdx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 48
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-PREP10-LABEL: ld_align64_uint16_t_double:
 ; CHECK-PREP10:       # %bb.0: # %entry
 ; CHECK-PREP10-NEXT:    lis r4, 3725
 ; CHECK-PREP10-NEXT:    ori r4, r4, 19025
 ; CHECK-PREP10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-PREP10-NEXT:    lfdx f0, r3, r4
 ; CHECK-PREP10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-PREP10-NEXT:    mffprwz r3, f0
-; CHECK-PREP10-NEXT:    clrldi r3, r3, 32
+; CHECK-PREP10-NEXT:    clrldi r3, r3, 48
 ; CHECK-PREP10-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 1000000000000
   %0 = bitcast i8* %add.ptr to double*
   %1 = load double, double* %0, align 8
   %conv = fptoui double %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i16 @ld_reg_uint16_t_double(i8* nocapture readonly %ptr, i64 %off) {
 ; CHECK-LABEL: ld_reg_uint16_t_double:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lfdx f0, r3, r4
 ; CHECK-NEXT:    xscvdpsxws f0, f0
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    clrldi r3, r3, 32
+; CHECK-NEXT:    clrldi r3, r3, 48
 ; CHECK-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 %off
   %0 = bitcast i8* %add.ptr to double*
   %1 = load double, double* %0, align 8
   %conv = fptoui double %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i16 @ld_or_uint16_t_double(i64 %ptr, i8 zeroext %off) {
 ; CHECK-P10-LABEL: ld_or_uint16_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    or r3, r4, r3
 ; CHECK-P10-NEXT:    lfd f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 48
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_or_uint16_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    or r3, r4, r3
 ; CHECK-P9-NEXT:    lfd f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 48
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_or_uint16_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    or r3, r4, r3
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 48
 ; CHECK-P8-NEXT:    blr
 entry:
   %conv = zext i8 %off to i64
   %or = or i64 %conv, %ptr
   %0 = inttoptr i64 %or to double*
   %1 = load double, double* %0, align 8
   %conv1 = fptoui double %1 to i16
   ret i16 %conv1
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i16 @ld_not_disjoint16_uint16_t_double(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_not_disjoint16_uint16_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    ori r3, r3, 6
 ; CHECK-P10-NEXT:    lfd f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 48
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_not_disjoint16_uint16_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    ori r3, r3, 6
 ; CHECK-P9-NEXT:    lfd f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 48
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_not_disjoint16_uint16_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    ori r3, r3, 6
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 48
 ; CHECK-P8-NEXT:    blr
 entry:
   %or = or i64 %ptr, 6
   %0 = inttoptr i64 %or to double*
   %1 = load double, double* %0, align 8
   %conv = fptoui double %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i16 @ld_disjoint_align16_uint16_t_double(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_disjoint_align16_uint16_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    rldicr r3, r3, 0, 51
 ; CHECK-P10-NEXT:    lfd f0, 24(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 48
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_disjoint_align16_uint16_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    rldicr r3, r3, 0, 51
 ; CHECK-P9-NEXT:    lfd f0, 24(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 48
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_disjoint_align16_uint16_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    rldicr r3, r3, 0, 51
 ; CHECK-P8-NEXT:    ori r3, r3, 24
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 48
 ; CHECK-P8-NEXT:    blr
 entry:
   %and = and i64 %ptr, -4096
   %or = or i64 %and, 24
   %0 = inttoptr i64 %or to double*
   %1 = load double, double* %0, align 8
   %conv = fptoui double %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i16 @ld_not_disjoint32_uint16_t_double(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_not_disjoint32_uint16_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    ori r3, r3, 34463
 ; CHECK-P10-NEXT:    oris r3, r3, 1
 ; CHECK-P10-NEXT:    lfd f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 48
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_not_disjoint32_uint16_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    ori r3, r3, 34463
 ; CHECK-P9-NEXT:    oris r3, r3, 1
 ; CHECK-P9-NEXT:    lfd f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 48
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_not_disjoint32_uint16_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    ori r3, r3, 34463
 ; CHECK-P8-NEXT:    oris r3, r3, 1
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 48
 ; CHECK-P8-NEXT:    blr
 entry:
   %or = or i64 %ptr, 99999
   %0 = inttoptr i64 %or to double*
   %1 = load double, double* %0, align 8
   %conv = fptoui double %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i16 @ld_disjoint_align32_uint16_t_double(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_disjoint_align32_uint16_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    lis r4, -15264
 ; CHECK-P10-NEXT:    and r3, r3, r4
 ; CHECK-P10-NEXT:    pli r4, 999990000
 ; CHECK-P10-NEXT:    lfdx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 48
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_disjoint_align32_uint16_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lis r4, -15264
 ; CHECK-P9-NEXT:    and r3, r3, r4
 ; CHECK-P9-NEXT:    lis r4, 15258
 ; CHECK-P9-NEXT:    ori r4, r4, 41712
 ; CHECK-P9-NEXT:    lfdx f0, r3, r4
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 48
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_disjoint_align32_uint16_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lis r4, -15264
 ; CHECK-P8-NEXT:    lis r5, 15258
 ; CHECK-P8-NEXT:    and r3, r3, r4
 ; CHECK-P8-NEXT:    ori r4, r5, 41712
 ; CHECK-P8-NEXT:    lfdx f0, r3, r4
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 48
 ; CHECK-P8-NEXT:    blr
 entry:
   %and = and i64 %ptr, -1000341504
   %or = or i64 %and, 999990000
   %0 = inttoptr i64 %or to double*
   %1 = load double, double* %0, align 16
   %conv = fptoui double %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i16 @ld_not_disjoint64_uint16_t_double(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_not_disjoint64_uint16_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 232
 ; CHECK-P10-NEXT:    pli r5, 3567587329
 ; CHECK-P10-NEXT:    rldimi r5, r4, 32, 0
 ; CHECK-P10-NEXT:    or r3, r3, r5
 ; CHECK-P10-NEXT:    lfd f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 48
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_not_disjoint64_uint16_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    li r4, 29
 ; CHECK-P9-NEXT:    rldic r4, r4, 35, 24
 ; CHECK-P9-NEXT:    oris r4, r4, 54437
 ; CHECK-P9-NEXT:    ori r4, r4, 4097
 ; CHECK-P9-NEXT:    or r3, r3, r4
 ; CHECK-P9-NEXT:    lfd f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 48
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_not_disjoint64_uint16_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    li r4, 29
 ; CHECK-P8-NEXT:    rldic r4, r4, 35, 24
 ; CHECK-P8-NEXT:    oris r4, r4, 54437
 ; CHECK-P8-NEXT:    ori r4, r4, 4097
 ; CHECK-P8-NEXT:    or r3, r3, r4
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 48
 ; CHECK-P8-NEXT:    blr
 entry:
   %or = or i64 %ptr, 1000000000001
   %0 = inttoptr i64 %or to double*
   %1 = load double, double* %0, align 8
   %conv = fptoui double %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i16 @ld_disjoint_align64_uint16_t_double(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_disjoint_align64_uint16_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 244140625
 ; CHECK-P10-NEXT:    rldicr r3, r3, 0, 23
 ; CHECK-P10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-P10-NEXT:    lfdx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 48
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-PREP10-LABEL: ld_disjoint_align64_uint16_t_double:
 ; CHECK-PREP10:       # %bb.0: # %entry
 ; CHECK-PREP10-NEXT:    lis r4, 3725
 ; CHECK-PREP10-NEXT:    rldicr r3, r3, 0, 23
 ; CHECK-PREP10-NEXT:    ori r4, r4, 19025
 ; CHECK-PREP10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-PREP10-NEXT:    lfdx f0, r3, r4
 ; CHECK-PREP10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-PREP10-NEXT:    mffprwz r3, f0
-; CHECK-PREP10-NEXT:    clrldi r3, r3, 32
+; CHECK-PREP10-NEXT:    clrldi r3, r3, 48
 ; CHECK-PREP10-NEXT:    blr
 entry:
   %and = and i64 %ptr, -1099511627776
   %or = or i64 %and, 1000000000000
   %0 = inttoptr i64 %or to double*
   %1 = load double, double* %0, align 4096
   %conv = fptoui double %1 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i16 @ld_cst_align16_uint16_t_double() {
 ; CHECK-LABEL: ld_cst_align16_uint16_t_double:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lfd f0, 4080(0)
 ; CHECK-NEXT:    xscvdpsxws f0, f0
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    clrldi r3, r3, 32
+; CHECK-NEXT:    clrldi r3, r3, 48
 ; CHECK-NEXT:    blr
 entry:
   %0 = load double, double* inttoptr (i64 4080 to double*), align 16
   %conv = fptoui double %0 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i16 @ld_cst_align32_uint16_t_double() {
 ; CHECK-P10-LABEL: ld_cst_align32_uint16_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    lis r3, 153
 ; CHECK-P10-NEXT:    lfd f0, -27108(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 48
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_cst_align32_uint16_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lis r3, 153
 ; CHECK-P9-NEXT:    lfd f0, -27108(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 48
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_cst_align32_uint16_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lis r3, 152
 ; CHECK-P8-NEXT:    ori r3, r3, 38428
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 48
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = load double, double* inttoptr (i64 9999900 to double*), align 8
   %conv = fptoui double %0 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i16 @ld_cst_align64_uint16_t_double() {
 ; CHECK-P10-LABEL: ld_cst_align64_uint16_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r3, 244140625
 ; CHECK-P10-NEXT:    rldic r3, r3, 12, 24
 ; CHECK-P10-NEXT:    lfd f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 48
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_cst_align64_uint16_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lis r3, 3725
 ; CHECK-P9-NEXT:    ori r3, r3, 19025
 ; CHECK-P9-NEXT:    rldic r3, r3, 12, 24
 ; CHECK-P9-NEXT:    lfd f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 48
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_cst_align64_uint16_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lis r3, 3725
 ; CHECK-P8-NEXT:    ori r3, r3, 19025
 ; CHECK-P8-NEXT:    rldic r3, r3, 12, 24
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 48
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = load double, double* inttoptr (i64 1000000000000 to double*), align 4096
   %conv = fptoui double %0 to i16
   ret i16 %conv
 }
 
 ; Function Attrs: nofree norecurse nounwind uwtable willreturn writeonly

llvm/test/CodeGen/PowerPC/scalar-i8-ldst.ll

 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i8 @ld_0_int8_t_float(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_0_int8_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    lfs f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsb r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_0_int8_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lfs f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsb r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_0_int8_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsb r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = inttoptr i64 %ptr to float*
   %1 = load float, float* %0, align 4
   %conv = fptosi float %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i8 @ld_align16_int8_t_float(i8* nocapture readonly %ptr) {
 ; CHECK-LABEL: ld_align16_int8_t_float:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lfs f0, 8(r3)
 ; CHECK-NEXT:    xscvdpsxws f0, f0
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    extsw r3, r3
+; CHECK-NEXT:    extsb r3, r3
 ; CHECK-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 8
   %0 = bitcast i8* %add.ptr to float*
   %1 = load float, float* %0, align 4
   %conv = fptosi float %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i8 @ld_align32_int8_t_float(i8* nocapture readonly %ptr) {
 ; CHECK-P10-LABEL: ld_align32_int8_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 99999000
 ; CHECK-P10-NEXT:    lfsx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsb r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-PREP10-LABEL: ld_align32_int8_t_float:
 ; CHECK-PREP10:       # %bb.0: # %entry
 ; CHECK-PREP10-NEXT:    lis r4, 1525
 ; CHECK-PREP10-NEXT:    ori r4, r4, 56600
 ; CHECK-PREP10-NEXT:    lfsx f0, r3, r4
 ; CHECK-PREP10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-PREP10-NEXT:    mffprwz r3, f0
-; CHECK-PREP10-NEXT:    extsw r3, r3
+; CHECK-PREP10-NEXT:    extsb r3, r3
 ; CHECK-PREP10-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 99999000
   %0 = bitcast i8* %add.ptr to float*
   %1 = load float, float* %0, align 4
   %conv = fptosi float %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i8 @ld_align64_int8_t_float(i8* nocapture readonly %ptr) {
 ; CHECK-P10-LABEL: ld_align64_int8_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 244140625
 ; CHECK-P10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-P10-NEXT:    lfsx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsb r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-PREP10-LABEL: ld_align64_int8_t_float:
 ; CHECK-PREP10:       # %bb.0: # %entry
 ; CHECK-PREP10-NEXT:    lis r4, 3725
 ; CHECK-PREP10-NEXT:    ori r4, r4, 19025
 ; CHECK-PREP10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-PREP10-NEXT:    lfsx f0, r3, r4
 ; CHECK-PREP10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-PREP10-NEXT:    mffprwz r3, f0
-; CHECK-PREP10-NEXT:    extsw r3, r3
+; CHECK-PREP10-NEXT:    extsb r3, r3
 ; CHECK-PREP10-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 1000000000000
   %0 = bitcast i8* %add.ptr to float*
   %1 = load float, float* %0, align 4
   %conv = fptosi float %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i8 @ld_reg_int8_t_float(i8* nocapture readonly %ptr, i64 %off) {
 ; CHECK-LABEL: ld_reg_int8_t_float:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lfsx f0, r3, r4
 ; CHECK-NEXT:    xscvdpsxws f0, f0
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    extsw r3, r3
+; CHECK-NEXT:    extsb r3, r3
 ; CHECK-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 %off
   %0 = bitcast i8* %add.ptr to float*
   %1 = load float, float* %0, align 4
   %conv = fptosi float %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i8 @ld_or_int8_t_float(i64 %ptr, i8 zeroext %off) {
 ; CHECK-P10-LABEL: ld_or_int8_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    or r3, r4, r3
 ; CHECK-P10-NEXT:    lfs f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsb r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_or_int8_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    or r3, r4, r3
 ; CHECK-P9-NEXT:    lfs f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsb r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_or_int8_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    or r3, r4, r3
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsb r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %conv = zext i8 %off to i64
   %or = or i64 %conv, %ptr
   %0 = inttoptr i64 %or to float*
   %1 = load float, float* %0, align 4
   %conv1 = fptosi float %1 to i8
   ret i8 %conv1
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i8 @ld_not_disjoint16_int8_t_float(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_not_disjoint16_int8_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    ori r3, r3, 6
 ; CHECK-P10-NEXT:    lfs f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsb r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_not_disjoint16_int8_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    ori r3, r3, 6
 ; CHECK-P9-NEXT:    lfs f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsb r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_not_disjoint16_int8_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    ori r3, r3, 6
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsb r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %or = or i64 %ptr, 6
   %0 = inttoptr i64 %or to float*
   %1 = load float, float* %0, align 4
   %conv = fptosi float %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i8 @ld_disjoint_align16_int8_t_float(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_disjoint_align16_int8_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    rldicr r3, r3, 0, 51
 ; CHECK-P10-NEXT:    lfs f0, 24(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsb r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_disjoint_align16_int8_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    rldicr r3, r3, 0, 51
 ; CHECK-P9-NEXT:    lfs f0, 24(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsb r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_disjoint_align16_int8_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    rldicr r3, r3, 0, 51
 ; CHECK-P8-NEXT:    ori r3, r3, 24
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsb r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %and = and i64 %ptr, -4096
   %or = or i64 %and, 24
   %0 = inttoptr i64 %or to float*
   %1 = load float, float* %0, align 8
   %conv = fptosi float %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i8 @ld_not_disjoint32_int8_t_float(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_not_disjoint32_int8_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    ori r3, r3, 34463
 ; CHECK-P10-NEXT:    oris r3, r3, 1
 ; CHECK-P10-NEXT:    lfs f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsb r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_not_disjoint32_int8_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    ori r3, r3, 34463
 ; CHECK-P9-NEXT:    oris r3, r3, 1
 ; CHECK-P9-NEXT:    lfs f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsb r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_not_disjoint32_int8_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    ori r3, r3, 34463
 ; CHECK-P8-NEXT:    oris r3, r3, 1
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsb r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %or = or i64 %ptr, 99999
   %0 = inttoptr i64 %or to float*
   %1 = load float, float* %0, align 4
   %conv = fptosi float %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i8 @ld_disjoint_align32_int8_t_float(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_disjoint_align32_int8_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    lis r4, -15264
 ; CHECK-P10-NEXT:    and r3, r3, r4
 ; CHECK-P10-NEXT:    pli r4, 999990000
 ; CHECK-P10-NEXT:    lfsx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsb r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_disjoint_align32_int8_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lis r4, -15264
 ; CHECK-P9-NEXT:    and r3, r3, r4
 ; CHECK-P9-NEXT:    lis r4, 15258
 ; CHECK-P9-NEXT:    ori r4, r4, 41712
 ; CHECK-P9-NEXT:    lfsx f0, r3, r4
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsb r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_disjoint_align32_int8_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lis r4, -15264
 ; CHECK-P8-NEXT:    lis r5, 15258
 ; CHECK-P8-NEXT:    and r3, r3, r4
 ; CHECK-P8-NEXT:    ori r4, r5, 41712
 ; CHECK-P8-NEXT:    lfsx f0, r3, r4
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsb r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %and = and i64 %ptr, -1000341504
   %or = or i64 %and, 999990000
   %0 = inttoptr i64 %or to float*
   %1 = load float, float* %0, align 16
   %conv = fptosi float %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i8 @ld_not_disjoint64_int8_t_float(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_not_disjoint64_int8_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 232
 ; CHECK-P10-NEXT:    pli r5, 3567587329
 ; CHECK-P10-NEXT:    rldimi r5, r4, 32, 0
 ; CHECK-P10-NEXT:    or r3, r3, r5
 ; CHECK-P10-NEXT:    lfs f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsb r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_not_disjoint64_int8_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    li r4, 29
 ; CHECK-P9-NEXT:    rldic r4, r4, 35, 24
 ; CHECK-P9-NEXT:    oris r4, r4, 54437
 ; CHECK-P9-NEXT:    ori r4, r4, 4097
 ; CHECK-P9-NEXT:    or r3, r3, r4
 ; CHECK-P9-NEXT:    lfs f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsb r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_not_disjoint64_int8_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    li r4, 29
 ; CHECK-P8-NEXT:    rldic r4, r4, 35, 24
 ; CHECK-P8-NEXT:    oris r4, r4, 54437
 ; CHECK-P8-NEXT:    ori r4, r4, 4097
 ; CHECK-P8-NEXT:    or r3, r3, r4
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsb r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %or = or i64 %ptr, 1000000000001
   %0 = inttoptr i64 %or to float*
   %1 = load float, float* %0, align 4
   %conv = fptosi float %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i8 @ld_disjoint_align64_int8_t_float(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_disjoint_align64_int8_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 244140625
 ; CHECK-P10-NEXT:    rldicr r3, r3, 0, 23
 ; CHECK-P10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-P10-NEXT:    lfsx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsb r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-PREP10-LABEL: ld_disjoint_align64_int8_t_float:
 ; CHECK-PREP10:       # %bb.0: # %entry
 ; CHECK-PREP10-NEXT:    lis r4, 3725
 ; CHECK-PREP10-NEXT:    rldicr r3, r3, 0, 23
 ; CHECK-PREP10-NEXT:    ori r4, r4, 19025
 ; CHECK-PREP10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-PREP10-NEXT:    lfsx f0, r3, r4
 ; CHECK-PREP10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-PREP10-NEXT:    mffprwz r3, f0
-; CHECK-PREP10-NEXT:    extsw r3, r3
+; CHECK-PREP10-NEXT:    extsb r3, r3
 ; CHECK-PREP10-NEXT:    blr
 entry:
   %and = and i64 %ptr, -1099511627776
   %or = or i64 %and, 1000000000000
   %0 = inttoptr i64 %or to float*
   %1 = load float, float* %0, align 4096
   %conv = fptosi float %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i8 @ld_cst_align16_int8_t_float() {
 ; CHECK-LABEL: ld_cst_align16_int8_t_float:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lfs f0, 4080(0)
 ; CHECK-NEXT:    xscvdpsxws f0, f0
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    extsw r3, r3
+; CHECK-NEXT:    extsb r3, r3
 ; CHECK-NEXT:    blr
 entry:
   %0 = load float, float* inttoptr (i64 4080 to float*), align 16
   %conv = fptosi float %0 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i8 @ld_cst_align32_int8_t_float() {
 ; CHECK-P10-LABEL: ld_cst_align32_int8_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    lis r3, 153
 ; CHECK-P10-NEXT:    lfs f0, -27108(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsb r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_cst_align32_int8_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lis r3, 153
 ; CHECK-P9-NEXT:    lfs f0, -27108(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsb r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_cst_align32_int8_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lis r3, 152
 ; CHECK-P8-NEXT:    ori r3, r3, 38428
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsb r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = load float, float* inttoptr (i64 9999900 to float*), align 4
   %conv = fptosi float %0 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i8 @ld_cst_align64_int8_t_float() {
 ; CHECK-P10-LABEL: ld_cst_align64_int8_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r3, 244140625
 ; CHECK-P10-NEXT:    rldic r3, r3, 12, 24
 ; CHECK-P10-NEXT:    lfs f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsb r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_cst_align64_int8_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lis r3, 3725
 ; CHECK-P9-NEXT:    ori r3, r3, 19025
 ; CHECK-P9-NEXT:    rldic r3, r3, 12, 24
 ; CHECK-P9-NEXT:    lfs f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsb r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_cst_align64_int8_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lis r3, 3725
 ; CHECK-P8-NEXT:    ori r3, r3, 19025
 ; CHECK-P8-NEXT:    rldic r3, r3, 12, 24
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsb r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = load float, float* inttoptr (i64 1000000000000 to float*), align 4096
   %conv = fptosi float %0 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i8 @ld_0_int8_t_double(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_0_int8_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    lfd f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsb r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_0_int8_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lfd f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsb r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_0_int8_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsb r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = inttoptr i64 %ptr to double*
   %1 = load double, double* %0, align 8
   %conv = fptosi double %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i8 @ld_align16_int8_t_double(i8* nocapture readonly %ptr) {
 ; CHECK-LABEL: ld_align16_int8_t_double:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lfd f0, 8(r3)
 ; CHECK-NEXT:    xscvdpsxws f0, f0
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    extsw r3, r3
+; CHECK-NEXT:    extsb r3, r3
 ; CHECK-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 8
   %0 = bitcast i8* %add.ptr to double*
   %1 = load double, double* %0, align 8
   %conv = fptosi double %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i8 @ld_align32_int8_t_double(i8* nocapture readonly %ptr) {
 ; CHECK-P10-LABEL: ld_align32_int8_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 99999000
 ; CHECK-P10-NEXT:    lfdx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsb r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-PREP10-LABEL: ld_align32_int8_t_double:
 ; CHECK-PREP10:       # %bb.0: # %entry
 ; CHECK-PREP10-NEXT:    lis r4, 1525
 ; CHECK-PREP10-NEXT:    ori r4, r4, 56600
 ; CHECK-PREP10-NEXT:    lfdx f0, r3, r4
 ; CHECK-PREP10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-PREP10-NEXT:    mffprwz r3, f0
-; CHECK-PREP10-NEXT:    extsw r3, r3
+; CHECK-PREP10-NEXT:    extsb r3, r3
 ; CHECK-PREP10-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 99999000
   %0 = bitcast i8* %add.ptr to double*
   %1 = load double, double* %0, align 8
   %conv = fptosi double %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i8 @ld_align64_int8_t_double(i8* nocapture readonly %ptr) {
 ; CHECK-P10-LABEL: ld_align64_int8_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 244140625
 ; CHECK-P10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-P10-NEXT:    lfdx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsb r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-PREP10-LABEL: ld_align64_int8_t_double:
 ; CHECK-PREP10:       # %bb.0: # %entry
 ; CHECK-PREP10-NEXT:    lis r4, 3725
 ; CHECK-PREP10-NEXT:    ori r4, r4, 19025
 ; CHECK-PREP10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-PREP10-NEXT:    lfdx f0, r3, r4
 ; CHECK-PREP10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-PREP10-NEXT:    mffprwz r3, f0
-; CHECK-PREP10-NEXT:    extsw r3, r3
+; CHECK-PREP10-NEXT:    extsb r3, r3
 ; CHECK-PREP10-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 1000000000000
   %0 = bitcast i8* %add.ptr to double*
   %1 = load double, double* %0, align 8
   %conv = fptosi double %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i8 @ld_reg_int8_t_double(i8* nocapture readonly %ptr, i64 %off) {
 ; CHECK-LABEL: ld_reg_int8_t_double:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lfdx f0, r3, r4
 ; CHECK-NEXT:    xscvdpsxws f0, f0
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    extsw r3, r3
+; CHECK-NEXT:    extsb r3, r3
 ; CHECK-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 %off
   %0 = bitcast i8* %add.ptr to double*
   %1 = load double, double* %0, align 8
   %conv = fptosi double %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i8 @ld_or_int8_t_double(i64 %ptr, i8 zeroext %off) {
 ; CHECK-P10-LABEL: ld_or_int8_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    or r3, r4, r3
 ; CHECK-P10-NEXT:    lfd f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsb r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_or_int8_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    or r3, r4, r3
 ; CHECK-P9-NEXT:    lfd f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsb r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_or_int8_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    or r3, r4, r3
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsb r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %conv = zext i8 %off to i64
   %or = or i64 %conv, %ptr
   %0 = inttoptr i64 %or to double*
   %1 = load double, double* %0, align 8
   %conv1 = fptosi double %1 to i8
   ret i8 %conv1
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i8 @ld_not_disjoint16_int8_t_double(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_not_disjoint16_int8_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    ori r3, r3, 6
 ; CHECK-P10-NEXT:    lfd f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsb r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_not_disjoint16_int8_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    ori r3, r3, 6
 ; CHECK-P9-NEXT:    lfd f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsb r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_not_disjoint16_int8_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    ori r3, r3, 6
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsb r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %or = or i64 %ptr, 6
   %0 = inttoptr i64 %or to double*
   %1 = load double, double* %0, align 8
   %conv = fptosi double %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i8 @ld_disjoint_align16_int8_t_double(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_disjoint_align16_int8_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    rldicr r3, r3, 0, 51
 ; CHECK-P10-NEXT:    lfd f0, 24(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsb r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_disjoint_align16_int8_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    rldicr r3, r3, 0, 51
 ; CHECK-P9-NEXT:    lfd f0, 24(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsb r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_disjoint_align16_int8_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    rldicr r3, r3, 0, 51
 ; CHECK-P8-NEXT:    ori r3, r3, 24
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsb r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %and = and i64 %ptr, -4096
   %or = or i64 %and, 24
   %0 = inttoptr i64 %or to double*
   %1 = load double, double* %0, align 8
   %conv = fptosi double %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i8 @ld_not_disjoint32_int8_t_double(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_not_disjoint32_int8_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    ori r3, r3, 34463
 ; CHECK-P10-NEXT:    oris r3, r3, 1
 ; CHECK-P10-NEXT:    lfd f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsb r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_not_disjoint32_int8_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    ori r3, r3, 34463
 ; CHECK-P9-NEXT:    oris r3, r3, 1
 ; CHECK-P9-NEXT:    lfd f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsb r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_not_disjoint32_int8_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    ori r3, r3, 34463
 ; CHECK-P8-NEXT:    oris r3, r3, 1
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsb r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %or = or i64 %ptr, 99999
   %0 = inttoptr i64 %or to double*
   %1 = load double, double* %0, align 8
   %conv = fptosi double %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i8 @ld_disjoint_align32_int8_t_double(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_disjoint_align32_int8_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    lis r4, -15264
 ; CHECK-P10-NEXT:    and r3, r3, r4
 ; CHECK-P10-NEXT:    pli r4, 999990000
 ; CHECK-P10-NEXT:    lfdx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsb r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_disjoint_align32_int8_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lis r4, -15264
 ; CHECK-P9-NEXT:    and r3, r3, r4
 ; CHECK-P9-NEXT:    lis r4, 15258
 ; CHECK-P9-NEXT:    ori r4, r4, 41712
 ; CHECK-P9-NEXT:    lfdx f0, r3, r4
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsb r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_disjoint_align32_int8_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lis r4, -15264
 ; CHECK-P8-NEXT:    lis r5, 15258
 ; CHECK-P8-NEXT:    and r3, r3, r4
 ; CHECK-P8-NEXT:    ori r4, r5, 41712
 ; CHECK-P8-NEXT:    lfdx f0, r3, r4
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsb r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %and = and i64 %ptr, -1000341504
   %or = or i64 %and, 999990000
   %0 = inttoptr i64 %or to double*
   %1 = load double, double* %0, align 16
   %conv = fptosi double %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i8 @ld_not_disjoint64_int8_t_double(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_not_disjoint64_int8_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 232
 ; CHECK-P10-NEXT:    pli r5, 3567587329
 ; CHECK-P10-NEXT:    rldimi r5, r4, 32, 0
 ; CHECK-P10-NEXT:    or r3, r3, r5
 ; CHECK-P10-NEXT:    lfd f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsb r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_not_disjoint64_int8_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    li r4, 29
 ; CHECK-P9-NEXT:    rldic r4, r4, 35, 24
 ; CHECK-P9-NEXT:    oris r4, r4, 54437
 ; CHECK-P9-NEXT:    ori r4, r4, 4097
 ; CHECK-P9-NEXT:    or r3, r3, r4
 ; CHECK-P9-NEXT:    lfd f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsb r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_not_disjoint64_int8_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    li r4, 29
 ; CHECK-P8-NEXT:    rldic r4, r4, 35, 24
 ; CHECK-P8-NEXT:    oris r4, r4, 54437
 ; CHECK-P8-NEXT:    ori r4, r4, 4097
 ; CHECK-P8-NEXT:    or r3, r3, r4
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsb r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %or = or i64 %ptr, 1000000000001
   %0 = inttoptr i64 %or to double*
   %1 = load double, double* %0, align 8
   %conv = fptosi double %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i8 @ld_disjoint_align64_int8_t_double(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_disjoint_align64_int8_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 244140625
 ; CHECK-P10-NEXT:    rldicr r3, r3, 0, 23
 ; CHECK-P10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-P10-NEXT:    lfdx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsb r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-PREP10-LABEL: ld_disjoint_align64_int8_t_double:
 ; CHECK-PREP10:       # %bb.0: # %entry
 ; CHECK-PREP10-NEXT:    lis r4, 3725
 ; CHECK-PREP10-NEXT:    rldicr r3, r3, 0, 23
 ; CHECK-PREP10-NEXT:    ori r4, r4, 19025
 ; CHECK-PREP10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-PREP10-NEXT:    lfdx f0, r3, r4
 ; CHECK-PREP10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-PREP10-NEXT:    mffprwz r3, f0
-; CHECK-PREP10-NEXT:    extsw r3, r3
+; CHECK-PREP10-NEXT:    extsb r3, r3
 ; CHECK-PREP10-NEXT:    blr
 entry:
   %and = and i64 %ptr, -1099511627776
   %or = or i64 %and, 1000000000000
   %0 = inttoptr i64 %or to double*
   %1 = load double, double* %0, align 4096
   %conv = fptosi double %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i8 @ld_cst_align16_int8_t_double() {
 ; CHECK-LABEL: ld_cst_align16_int8_t_double:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lfd f0, 4080(0)
 ; CHECK-NEXT:    xscvdpsxws f0, f0
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    extsw r3, r3
+; CHECK-NEXT:    extsb r3, r3
 ; CHECK-NEXT:    blr
 entry:
   %0 = load double, double* inttoptr (i64 4080 to double*), align 16
   %conv = fptosi double %0 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i8 @ld_cst_align32_int8_t_double() {
 ; CHECK-P10-LABEL: ld_cst_align32_int8_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    lis r3, 153
 ; CHECK-P10-NEXT:    lfd f0, -27108(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsb r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_cst_align32_int8_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lis r3, 153
 ; CHECK-P9-NEXT:    lfd f0, -27108(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsb r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_cst_align32_int8_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lis r3, 152
 ; CHECK-P8-NEXT:    ori r3, r3, 38428
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsb r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = load double, double* inttoptr (i64 9999900 to double*), align 8
   %conv = fptosi double %0 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local signext i8 @ld_cst_align64_int8_t_double() {
 ; CHECK-P10-LABEL: ld_cst_align64_int8_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r3, 244140625
 ; CHECK-P10-NEXT:    rldic r3, r3, 12, 24
 ; CHECK-P10-NEXT:    lfd f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    extsw r3, r3
+; CHECK-P10-NEXT:    extsb r3, r3
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_cst_align64_int8_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lis r3, 3725
 ; CHECK-P9-NEXT:    ori r3, r3, 19025
 ; CHECK-P9-NEXT:    rldic r3, r3, 12, 24
 ; CHECK-P9-NEXT:    lfd f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    extsw r3, r3
+; CHECK-P9-NEXT:    extsb r3, r3
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_cst_align64_int8_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lis r3, 3725
 ; CHECK-P8-NEXT:    ori r3, r3, 19025
 ; CHECK-P8-NEXT:    rldic r3, r3, 12, 24
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    extsw r3, r3
+; CHECK-P8-NEXT:    extsb r3, r3
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = load double, double* inttoptr (i64 1000000000000 to double*), align 4096
   %conv = fptosi double %0 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn

 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_0_uint8_t_float(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_0_uint8_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    lfs f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 56
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_0_uint8_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lfs f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 56
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_0_uint8_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 56
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = inttoptr i64 %ptr to float*
   %1 = load float, float* %0, align 4
   %conv = fptoui float %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_align16_uint8_t_float(i8* nocapture readonly %ptr) {
 ; CHECK-LABEL: ld_align16_uint8_t_float:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lfs f0, 8(r3)
 ; CHECK-NEXT:    xscvdpsxws f0, f0
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    clrldi r3, r3, 32
+; CHECK-NEXT:    clrldi r3, r3, 56
 ; CHECK-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 8
   %0 = bitcast i8* %add.ptr to float*
   %1 = load float, float* %0, align 4
   %conv = fptoui float %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_align32_uint8_t_float(i8* nocapture readonly %ptr) {
 ; CHECK-P10-LABEL: ld_align32_uint8_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 99999000
 ; CHECK-P10-NEXT:    lfsx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 56
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-PREP10-LABEL: ld_align32_uint8_t_float:
 ; CHECK-PREP10:       # %bb.0: # %entry
 ; CHECK-PREP10-NEXT:    lis r4, 1525
 ; CHECK-PREP10-NEXT:    ori r4, r4, 56600
 ; CHECK-PREP10-NEXT:    lfsx f0, r3, r4
 ; CHECK-PREP10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-PREP10-NEXT:    mffprwz r3, f0
-; CHECK-PREP10-NEXT:    clrldi r3, r3, 32
+; CHECK-PREP10-NEXT:    clrldi r3, r3, 56
 ; CHECK-PREP10-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 99999000
   %0 = bitcast i8* %add.ptr to float*
   %1 = load float, float* %0, align 4
   %conv = fptoui float %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_unalign64_uint8_t_float(i8* nocapture readonly %ptr) {
 ; CHECK-P10-LABEL: ld_unalign64_uint8_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 232
 ; CHECK-P10-NEXT:    pli r5, 3567587329
 ; CHECK-P10-NEXT:    rldimi r5, r4, 32, 0
 ; CHECK-P10-NEXT:    lfsx f0, r3, r5
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 56
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-PREP10-LABEL: ld_unalign64_uint8_t_float:
 ; CHECK-PREP10:       # %bb.0: # %entry
 ; CHECK-PREP10-NEXT:    li r4, 29
 ; CHECK-PREP10-NEXT:    rldic r4, r4, 35, 24
 ; CHECK-PREP10-NEXT:    oris r4, r4, 54437
 ; CHECK-PREP10-NEXT:    ori r4, r4, 4097
 ; CHECK-PREP10-NEXT:    lfsx f0, r3, r4
 ; CHECK-PREP10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-PREP10-NEXT:    mffprwz r3, f0
-; CHECK-PREP10-NEXT:    clrldi r3, r3, 32
+; CHECK-PREP10-NEXT:    clrldi r3, r3, 56
 ; CHECK-PREP10-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 1000000000001
   %0 = bitcast i8* %add.ptr to float*
   %1 = load float, float* %0, align 4
   %conv = fptoui float %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_align64_uint8_t_float(i8* nocapture readonly %ptr) {
 ; CHECK-P10-LABEL: ld_align64_uint8_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 244140625
 ; CHECK-P10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-P10-NEXT:    lfsx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 56
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-PREP10-LABEL: ld_align64_uint8_t_float:
 ; CHECK-PREP10:       # %bb.0: # %entry
 ; CHECK-PREP10-NEXT:    lis r4, 3725
 ; CHECK-PREP10-NEXT:    ori r4, r4, 19025
 ; CHECK-PREP10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-PREP10-NEXT:    lfsx f0, r3, r4
 ; CHECK-PREP10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-PREP10-NEXT:    mffprwz r3, f0
-; CHECK-PREP10-NEXT:    clrldi r3, r3, 32
+; CHECK-PREP10-NEXT:    clrldi r3, r3, 56
 ; CHECK-PREP10-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 1000000000000
   %0 = bitcast i8* %add.ptr to float*
   %1 = load float, float* %0, align 4
   %conv = fptoui float %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_reg_uint8_t_float(i8* nocapture readonly %ptr, i64 %off) {
 ; CHECK-LABEL: ld_reg_uint8_t_float:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lfsx f0, r3, r4
 ; CHECK-NEXT:    xscvdpsxws f0, f0
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    clrldi r3, r3, 32
+; CHECK-NEXT:    clrldi r3, r3, 56
 ; CHECK-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 %off
   %0 = bitcast i8* %add.ptr to float*
   %1 = load float, float* %0, align 4
   %conv = fptoui float %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_or_uint8_t_float(i64 %ptr, i8 zeroext %off) {
 ; CHECK-P10-LABEL: ld_or_uint8_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    or r3, r4, r3
 ; CHECK-P10-NEXT:    lfs f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 56
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_or_uint8_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    or r3, r4, r3
 ; CHECK-P9-NEXT:    lfs f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 56
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_or_uint8_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    or r3, r4, r3
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 56
 ; CHECK-P8-NEXT:    blr
 entry:
   %conv = zext i8 %off to i64
   %or = or i64 %conv, %ptr
   %0 = inttoptr i64 %or to float*
   %1 = load float, float* %0, align 4
   %conv1 = fptoui float %1 to i8
   ret i8 %conv1
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_not_disjoint16_uint8_t_float(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_not_disjoint16_uint8_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    ori r3, r3, 6
 ; CHECK-P10-NEXT:    lfs f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 56
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_not_disjoint16_uint8_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    ori r3, r3, 6
 ; CHECK-P9-NEXT:    lfs f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 56
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_not_disjoint16_uint8_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    ori r3, r3, 6
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 56
 ; CHECK-P8-NEXT:    blr
 entry:
   %or = or i64 %ptr, 6
   %0 = inttoptr i64 %or to float*
   %1 = load float, float* %0, align 4
   %conv = fptoui float %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_disjoint_align16_uint8_t_float(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_disjoint_align16_uint8_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    rldicr r3, r3, 0, 51
 ; CHECK-P10-NEXT:    lfs f0, 24(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 56
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_disjoint_align16_uint8_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    rldicr r3, r3, 0, 51
 ; CHECK-P9-NEXT:    lfs f0, 24(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 56
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_disjoint_align16_uint8_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    rldicr r3, r3, 0, 51
 ; CHECK-P8-NEXT:    ori r3, r3, 24
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 56
 ; CHECK-P8-NEXT:    blr
 entry:
   %and = and i64 %ptr, -4096
   %or = or i64 %and, 24
   %0 = inttoptr i64 %or to float*
   %1 = load float, float* %0, align 8
   %conv = fptoui float %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_not_disjoint32_uint8_t_float(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_not_disjoint32_uint8_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    ori r3, r3, 34463
 ; CHECK-P10-NEXT:    oris r3, r3, 1
 ; CHECK-P10-NEXT:    lfs f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 56
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_not_disjoint32_uint8_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    ori r3, r3, 34463
 ; CHECK-P9-NEXT:    oris r3, r3, 1
 ; CHECK-P9-NEXT:    lfs f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 56
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_not_disjoint32_uint8_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    ori r3, r3, 34463
 ; CHECK-P8-NEXT:    oris r3, r3, 1
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 56
 ; CHECK-P8-NEXT:    blr
 entry:
   %or = or i64 %ptr, 99999
   %0 = inttoptr i64 %or to float*
   %1 = load float, float* %0, align 4
   %conv = fptoui float %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_disjoint_align32_uint8_t_float(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_disjoint_align32_uint8_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    lis r4, -15264
 ; CHECK-P10-NEXT:    and r3, r3, r4
 ; CHECK-P10-NEXT:    pli r4, 999990000
 ; CHECK-P10-NEXT:    lfsx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 56
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_disjoint_align32_uint8_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lis r4, -15264
 ; CHECK-P9-NEXT:    and r3, r3, r4
 ; CHECK-P9-NEXT:    lis r4, 15258
 ; CHECK-P9-NEXT:    ori r4, r4, 41712
 ; CHECK-P9-NEXT:    lfsx f0, r3, r4
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 56
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_disjoint_align32_uint8_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lis r4, -15264
 ; CHECK-P8-NEXT:    lis r5, 15258
 ; CHECK-P8-NEXT:    and r3, r3, r4
 ; CHECK-P8-NEXT:    ori r4, r5, 41712
 ; CHECK-P8-NEXT:    lfsx f0, r3, r4
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 56
 ; CHECK-P8-NEXT:    blr
 entry:
   %and = and i64 %ptr, -1000341504
   %or = or i64 %and, 999990000
   %0 = inttoptr i64 %or to float*
   %1 = load float, float* %0, align 16
   %conv = fptoui float %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_not_disjoint64_uint8_t_float(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_not_disjoint64_uint8_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 232
 ; CHECK-P10-NEXT:    pli r5, 3567587329
 ; CHECK-P10-NEXT:    rldimi r5, r4, 32, 0
 ; CHECK-P10-NEXT:    or r3, r3, r5
 ; CHECK-P10-NEXT:    lfs f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 56
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_not_disjoint64_uint8_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    li r4, 29
 ; CHECK-P9-NEXT:    rldic r4, r4, 35, 24
 ; CHECK-P9-NEXT:    oris r4, r4, 54437
 ; CHECK-P9-NEXT:    ori r4, r4, 4097
 ; CHECK-P9-NEXT:    or r3, r3, r4
 ; CHECK-P9-NEXT:    lfs f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 56
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_not_disjoint64_uint8_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    li r4, 29
 ; CHECK-P8-NEXT:    rldic r4, r4, 35, 24
 ; CHECK-P8-NEXT:    oris r4, r4, 54437
 ; CHECK-P8-NEXT:    ori r4, r4, 4097
 ; CHECK-P8-NEXT:    or r3, r3, r4
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 56
 ; CHECK-P8-NEXT:    blr
 entry:
   %or = or i64 %ptr, 1000000000001
   %0 = inttoptr i64 %or to float*
   %1 = load float, float* %0, align 4
   %conv = fptoui float %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_disjoint_unalign64_uint8_t_float(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_disjoint_unalign64_uint8_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 232
 ; CHECK-P10-NEXT:    pli r5, 3567587329
 ; CHECK-P10-NEXT:    rldicr r3, r3, 0, 23
 ; CHECK-P10-NEXT:    rldimi r5, r4, 32, 0
 ; CHECK-P10-NEXT:    lfsx f0, r3, r5
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 56
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-PREP10-LABEL: ld_disjoint_unalign64_uint8_t_float:
 ; CHECK-PREP10:       # %bb.0: # %entry
 ; CHECK-PREP10-NEXT:    li r4, 29
 ; CHECK-PREP10-NEXT:    rldicr r3, r3, 0, 23
 ; CHECK-PREP10-NEXT:    rldic r4, r4, 35, 24
 ; CHECK-PREP10-NEXT:    oris r4, r4, 54437
 ; CHECK-PREP10-NEXT:    ori r4, r4, 4097
 ; CHECK-PREP10-NEXT:    lfsx f0, r3, r4
 ; CHECK-PREP10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-PREP10-NEXT:    mffprwz r3, f0
-; CHECK-PREP10-NEXT:    clrldi r3, r3, 32
+; CHECK-PREP10-NEXT:    clrldi r3, r3, 56
 ; CHECK-PREP10-NEXT:    blr
 entry:
   %and = and i64 %ptr, -1099511627776
   %or = or i64 %and, 1000000000001
   %0 = inttoptr i64 %or to float*
   %1 = load float, float* %0, align 4
   %conv = fptoui float %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_disjoint_align64_uint8_t_float(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_disjoint_align64_uint8_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 244140625
 ; CHECK-P10-NEXT:    rldicr r3, r3, 0, 23
 ; CHECK-P10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-P10-NEXT:    lfsx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 56
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-PREP10-LABEL: ld_disjoint_align64_uint8_t_float:
 ; CHECK-PREP10:       # %bb.0: # %entry
 ; CHECK-PREP10-NEXT:    lis r4, 3725
 ; CHECK-PREP10-NEXT:    rldicr r3, r3, 0, 23
 ; CHECK-PREP10-NEXT:    ori r4, r4, 19025
 ; CHECK-PREP10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-PREP10-NEXT:    lfsx f0, r3, r4
 ; CHECK-PREP10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-PREP10-NEXT:    mffprwz r3, f0
-; CHECK-PREP10-NEXT:    clrldi r3, r3, 32
+; CHECK-PREP10-NEXT:    clrldi r3, r3, 56
 ; CHECK-PREP10-NEXT:    blr
 entry:
   %and = and i64 %ptr, -1099511627776
   %or = or i64 %and, 1000000000000
   %0 = inttoptr i64 %or to float*
   %1 = load float, float* %0, align 4096
   %conv = fptoui float %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_cst_align16_uint8_t_float() {
 ; CHECK-LABEL: ld_cst_align16_uint8_t_float:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lfs f0, 4080(0)
 ; CHECK-NEXT:    xscvdpsxws f0, f0
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    clrldi r3, r3, 32
+; CHECK-NEXT:    clrldi r3, r3, 56
 ; CHECK-NEXT:    blr
 entry:
   %0 = load float, float* inttoptr (i64 4080 to float*), align 16
   %conv = fptoui float %0 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_cst_align32_uint8_t_float() {
 ; CHECK-P10-LABEL: ld_cst_align32_uint8_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    lis r3, 153
 ; CHECK-P10-NEXT:    lfs f0, -27108(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 56
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_cst_align32_uint8_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lis r3, 153
 ; CHECK-P9-NEXT:    lfs f0, -27108(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 56
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_cst_align32_uint8_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lis r3, 152
 ; CHECK-P8-NEXT:    ori r3, r3, 38428
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 56
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = load float, float* inttoptr (i64 9999900 to float*), align 4
   %conv = fptoui float %0 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_cst_unalign64_uint8_t_float() {
 ; CHECK-P10-LABEL: ld_cst_unalign64_uint8_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r3, 232
 ; CHECK-P10-NEXT:    pli r4, 3567587329
 ; CHECK-P10-NEXT:    rldimi r4, r3, 32, 0
 ; CHECK-P10-NEXT:    lfs f0, 0(r4)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 56
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_cst_unalign64_uint8_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    li r3, 29
 ; CHECK-P9-NEXT:    rldic r3, r3, 35, 24
 ; CHECK-P9-NEXT:    oris r3, r3, 54437
 ; CHECK-P9-NEXT:    ori r3, r3, 4097
 ; CHECK-P9-NEXT:    lfs f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 56
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_cst_unalign64_uint8_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    li r3, 29
 ; CHECK-P8-NEXT:    rldic r3, r3, 35, 24
 ; CHECK-P8-NEXT:    oris r3, r3, 54437
 ; CHECK-P8-NEXT:    ori r3, r3, 4097
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 56
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = load float, float* inttoptr (i64 1000000000001 to float*), align 4
   %conv = fptoui float %0 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_cst_align64_uint8_t_float() {
 ; CHECK-P10-LABEL: ld_cst_align64_uint8_t_float:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r3, 244140625
 ; CHECK-P10-NEXT:    rldic r3, r3, 12, 24
 ; CHECK-P10-NEXT:    lfs f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 56
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_cst_align64_uint8_t_float:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lis r3, 3725
 ; CHECK-P9-NEXT:    ori r3, r3, 19025
 ; CHECK-P9-NEXT:    rldic r3, r3, 12, 24
 ; CHECK-P9-NEXT:    lfs f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 56
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_cst_align64_uint8_t_float:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lis r3, 3725
 ; CHECK-P8-NEXT:    ori r3, r3, 19025
 ; CHECK-P8-NEXT:    rldic r3, r3, 12, 24
 ; CHECK-P8-NEXT:    lfsx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 56
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = load float, float* inttoptr (i64 1000000000000 to float*), align 4096
   %conv = fptoui float %0 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_0_uint8_t_double(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_0_uint8_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    lfd f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 56
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_0_uint8_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lfd f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 56
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_0_uint8_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 56
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = inttoptr i64 %ptr to double*
   %1 = load double, double* %0, align 8
   %conv = fptoui double %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_align16_uint8_t_double(i8* nocapture readonly %ptr) {
 ; CHECK-LABEL: ld_align16_uint8_t_double:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lfd f0, 8(r3)
 ; CHECK-NEXT:    xscvdpsxws f0, f0
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    clrldi r3, r3, 32
+; CHECK-NEXT:    clrldi r3, r3, 56
 ; CHECK-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 8
   %0 = bitcast i8* %add.ptr to double*
   %1 = load double, double* %0, align 8
   %conv = fptoui double %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_align32_uint8_t_double(i8* nocapture readonly %ptr) {
 ; CHECK-P10-LABEL: ld_align32_uint8_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 99999000
 ; CHECK-P10-NEXT:    lfdx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 56
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-PREP10-LABEL: ld_align32_uint8_t_double:
 ; CHECK-PREP10:       # %bb.0: # %entry
 ; CHECK-PREP10-NEXT:    lis r4, 1525
 ; CHECK-PREP10-NEXT:    ori r4, r4, 56600
 ; CHECK-PREP10-NEXT:    lfdx f0, r3, r4
 ; CHECK-PREP10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-PREP10-NEXT:    mffprwz r3, f0
-; CHECK-PREP10-NEXT:    clrldi r3, r3, 32
+; CHECK-PREP10-NEXT:    clrldi r3, r3, 56
 ; CHECK-PREP10-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 99999000
   %0 = bitcast i8* %add.ptr to double*
   %1 = load double, double* %0, align 8
   %conv = fptoui double %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_unalign64_uint8_t_double(i8* nocapture readonly %ptr) {
 ; CHECK-P10-LABEL: ld_unalign64_uint8_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 232
 ; CHECK-P10-NEXT:    pli r5, 3567587329
 ; CHECK-P10-NEXT:    rldimi r5, r4, 32, 0
 ; CHECK-P10-NEXT:    lfdx f0, r3, r5
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 56
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-PREP10-LABEL: ld_unalign64_uint8_t_double:
 ; CHECK-PREP10:       # %bb.0: # %entry
 ; CHECK-PREP10-NEXT:    li r4, 29
 ; CHECK-PREP10-NEXT:    rldic r4, r4, 35, 24
 ; CHECK-PREP10-NEXT:    oris r4, r4, 54437
 ; CHECK-PREP10-NEXT:    ori r4, r4, 4097
 ; CHECK-PREP10-NEXT:    lfdx f0, r3, r4
 ; CHECK-PREP10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-PREP10-NEXT:    mffprwz r3, f0
-; CHECK-PREP10-NEXT:    clrldi r3, r3, 32
+; CHECK-PREP10-NEXT:    clrldi r3, r3, 56
 ; CHECK-PREP10-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 1000000000001
   %0 = bitcast i8* %add.ptr to double*
   %1 = load double, double* %0, align 8
   %conv = fptoui double %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_align64_uint8_t_double(i8* nocapture readonly %ptr) {
 ; CHECK-P10-LABEL: ld_align64_uint8_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 244140625
 ; CHECK-P10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-P10-NEXT:    lfdx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 56
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-PREP10-LABEL: ld_align64_uint8_t_double:
 ; CHECK-PREP10:       # %bb.0: # %entry
 ; CHECK-PREP10-NEXT:    lis r4, 3725
 ; CHECK-PREP10-NEXT:    ori r4, r4, 19025
 ; CHECK-PREP10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-PREP10-NEXT:    lfdx f0, r3, r4
 ; CHECK-PREP10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-PREP10-NEXT:    mffprwz r3, f0
-; CHECK-PREP10-NEXT:    clrldi r3, r3, 32
+; CHECK-PREP10-NEXT:    clrldi r3, r3, 56
 ; CHECK-PREP10-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 1000000000000
   %0 = bitcast i8* %add.ptr to double*
   %1 = load double, double* %0, align 8
   %conv = fptoui double %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_reg_uint8_t_double(i8* nocapture readonly %ptr, i64 %off) {
 ; CHECK-LABEL: ld_reg_uint8_t_double:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lfdx f0, r3, r4
 ; CHECK-NEXT:    xscvdpsxws f0, f0
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    clrldi r3, r3, 32
+; CHECK-NEXT:    clrldi r3, r3, 56
 ; CHECK-NEXT:    blr
 entry:
   %add.ptr = getelementptr inbounds i8, i8* %ptr, i64 %off
   %0 = bitcast i8* %add.ptr to double*
   %1 = load double, double* %0, align 8
   %conv = fptoui double %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_or_uint8_t_double(i64 %ptr, i8 zeroext %off) {
 ; CHECK-P10-LABEL: ld_or_uint8_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    or r3, r4, r3
 ; CHECK-P10-NEXT:    lfd f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 56
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_or_uint8_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    or r3, r4, r3
 ; CHECK-P9-NEXT:    lfd f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 56
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_or_uint8_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    or r3, r4, r3
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 56
 ; CHECK-P8-NEXT:    blr
 entry:
   %conv = zext i8 %off to i64
   %or = or i64 %conv, %ptr
   %0 = inttoptr i64 %or to double*
   %1 = load double, double* %0, align 8
   %conv1 = fptoui double %1 to i8
   ret i8 %conv1
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_not_disjoint16_uint8_t_double(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_not_disjoint16_uint8_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    ori r3, r3, 6
 ; CHECK-P10-NEXT:    lfd f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 56
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_not_disjoint16_uint8_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    ori r3, r3, 6
 ; CHECK-P9-NEXT:    lfd f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 56
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_not_disjoint16_uint8_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    ori r3, r3, 6
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 56
 ; CHECK-P8-NEXT:    blr
 entry:
   %or = or i64 %ptr, 6
   %0 = inttoptr i64 %or to double*
   %1 = load double, double* %0, align 8
   %conv = fptoui double %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_disjoint_align16_uint8_t_double(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_disjoint_align16_uint8_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    rldicr r3, r3, 0, 51
 ; CHECK-P10-NEXT:    lfd f0, 24(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 56
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_disjoint_align16_uint8_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    rldicr r3, r3, 0, 51
 ; CHECK-P9-NEXT:    lfd f0, 24(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 56
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_disjoint_align16_uint8_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    rldicr r3, r3, 0, 51
 ; CHECK-P8-NEXT:    ori r3, r3, 24
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 56
 ; CHECK-P8-NEXT:    blr
 entry:
   %and = and i64 %ptr, -4096
   %or = or i64 %and, 24
   %0 = inttoptr i64 %or to double*
   %1 = load double, double* %0, align 8
   %conv = fptoui double %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_not_disjoint32_uint8_t_double(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_not_disjoint32_uint8_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    ori r3, r3, 34463
 ; CHECK-P10-NEXT:    oris r3, r3, 1
 ; CHECK-P10-NEXT:    lfd f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 56
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_not_disjoint32_uint8_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    ori r3, r3, 34463
 ; CHECK-P9-NEXT:    oris r3, r3, 1
 ; CHECK-P9-NEXT:    lfd f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 56
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_not_disjoint32_uint8_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    ori r3, r3, 34463
 ; CHECK-P8-NEXT:    oris r3, r3, 1
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 56
 ; CHECK-P8-NEXT:    blr
 entry:
   %or = or i64 %ptr, 99999
   %0 = inttoptr i64 %or to double*
   %1 = load double, double* %0, align 8
   %conv = fptoui double %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_disjoint_align32_uint8_t_double(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_disjoint_align32_uint8_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    lis r4, -15264
 ; CHECK-P10-NEXT:    and r3, r3, r4
 ; CHECK-P10-NEXT:    pli r4, 999990000
 ; CHECK-P10-NEXT:    lfdx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 56
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_disjoint_align32_uint8_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lis r4, -15264
 ; CHECK-P9-NEXT:    and r3, r3, r4
 ; CHECK-P9-NEXT:    lis r4, 15258
 ; CHECK-P9-NEXT:    ori r4, r4, 41712
 ; CHECK-P9-NEXT:    lfdx f0, r3, r4
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 56
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_disjoint_align32_uint8_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lis r4, -15264
 ; CHECK-P8-NEXT:    lis r5, 15258
 ; CHECK-P8-NEXT:    and r3, r3, r4
 ; CHECK-P8-NEXT:    ori r4, r5, 41712
 ; CHECK-P8-NEXT:    lfdx f0, r3, r4
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 56
 ; CHECK-P8-NEXT:    blr
 entry:
   %and = and i64 %ptr, -1000341504
   %or = or i64 %and, 999990000
   %0 = inttoptr i64 %or to double*
   %1 = load double, double* %0, align 16
   %conv = fptoui double %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_not_disjoint64_uint8_t_double(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_not_disjoint64_uint8_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 232
 ; CHECK-P10-NEXT:    pli r5, 3567587329
 ; CHECK-P10-NEXT:    rldimi r5, r4, 32, 0
 ; CHECK-P10-NEXT:    or r3, r3, r5
 ; CHECK-P10-NEXT:    lfd f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 56
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_not_disjoint64_uint8_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    li r4, 29
 ; CHECK-P9-NEXT:    rldic r4, r4, 35, 24
 ; CHECK-P9-NEXT:    oris r4, r4, 54437
 ; CHECK-P9-NEXT:    ori r4, r4, 4097
 ; CHECK-P9-NEXT:    or r3, r3, r4
 ; CHECK-P9-NEXT:    lfd f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 56
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_not_disjoint64_uint8_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    li r4, 29
 ; CHECK-P8-NEXT:    rldic r4, r4, 35, 24
 ; CHECK-P8-NEXT:    oris r4, r4, 54437
 ; CHECK-P8-NEXT:    ori r4, r4, 4097
 ; CHECK-P8-NEXT:    or r3, r3, r4
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 56
 ; CHECK-P8-NEXT:    blr
 entry:
   %or = or i64 %ptr, 1000000000001
   %0 = inttoptr i64 %or to double*
   %1 = load double, double* %0, align 8
   %conv = fptoui double %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_disjoint_unalign64_uint8_t_double(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_disjoint_unalign64_uint8_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 232
 ; CHECK-P10-NEXT:    pli r5, 3567587329
 ; CHECK-P10-NEXT:    rldicr r3, r3, 0, 23
 ; CHECK-P10-NEXT:    rldimi r5, r4, 32, 0
 ; CHECK-P10-NEXT:    lfdx f0, r3, r5
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 56
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-PREP10-LABEL: ld_disjoint_unalign64_uint8_t_double:
 ; CHECK-PREP10:       # %bb.0: # %entry
 ; CHECK-PREP10-NEXT:    li r4, 29
 ; CHECK-PREP10-NEXT:    rldicr r3, r3, 0, 23
 ; CHECK-PREP10-NEXT:    rldic r4, r4, 35, 24
 ; CHECK-PREP10-NEXT:    oris r4, r4, 54437
 ; CHECK-PREP10-NEXT:    ori r4, r4, 4097
 ; CHECK-PREP10-NEXT:    lfdx f0, r3, r4
 ; CHECK-PREP10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-PREP10-NEXT:    mffprwz r3, f0
-; CHECK-PREP10-NEXT:    clrldi r3, r3, 32
+; CHECK-PREP10-NEXT:    clrldi r3, r3, 56
 ; CHECK-PREP10-NEXT:    blr
 entry:
   %and = and i64 %ptr, -1099511627776
   %or = or i64 %and, 1000000000001
   %0 = inttoptr i64 %or to double*
   %1 = load double, double* %0, align 8
   %conv = fptoui double %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_disjoint_align64_uint8_t_double(i64 %ptr) {
 ; CHECK-P10-LABEL: ld_disjoint_align64_uint8_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r4, 244140625
 ; CHECK-P10-NEXT:    rldicr r3, r3, 0, 23
 ; CHECK-P10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-P10-NEXT:    lfdx f0, r3, r4
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 56
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-PREP10-LABEL: ld_disjoint_align64_uint8_t_double:
 ; CHECK-PREP10:       # %bb.0: # %entry
 ; CHECK-PREP10-NEXT:    lis r4, 3725
 ; CHECK-PREP10-NEXT:    rldicr r3, r3, 0, 23
 ; CHECK-PREP10-NEXT:    ori r4, r4, 19025
 ; CHECK-PREP10-NEXT:    rldic r4, r4, 12, 24
 ; CHECK-PREP10-NEXT:    lfdx f0, r3, r4
 ; CHECK-PREP10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-PREP10-NEXT:    mffprwz r3, f0
-; CHECK-PREP10-NEXT:    clrldi r3, r3, 32
+; CHECK-PREP10-NEXT:    clrldi r3, r3, 56
 ; CHECK-PREP10-NEXT:    blr
 entry:
   %and = and i64 %ptr, -1099511627776
   %or = or i64 %and, 1000000000000
   %0 = inttoptr i64 %or to double*
   %1 = load double, double* %0, align 4096
   %conv = fptoui double %1 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_cst_align16_uint8_t_double() {
 ; CHECK-LABEL: ld_cst_align16_uint8_t_double:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    lfd f0, 4080(0)
 ; CHECK-NEXT:    xscvdpsxws f0, f0
 ; CHECK-NEXT:    mffprwz r3, f0
-; CHECK-NEXT:    clrldi r3, r3, 32
+; CHECK-NEXT:    clrldi r3, r3, 56
 ; CHECK-NEXT:    blr
 entry:
   %0 = load double, double* inttoptr (i64 4080 to double*), align 16
   %conv = fptoui double %0 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_cst_align32_uint8_t_double() {
 ; CHECK-P10-LABEL: ld_cst_align32_uint8_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    lis r3, 153
 ; CHECK-P10-NEXT:    lfd f0, -27108(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 56
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_cst_align32_uint8_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lis r3, 153
 ; CHECK-P9-NEXT:    lfd f0, -27108(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 56
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_cst_align32_uint8_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lis r3, 152
 ; CHECK-P8-NEXT:    ori r3, r3, 38428
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 56
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = load double, double* inttoptr (i64 9999900 to double*), align 8
   %conv = fptoui double %0 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_cst_unalign64_uint8_t_double() {
 ; CHECK-P10-LABEL: ld_cst_unalign64_uint8_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r3, 232
 ; CHECK-P10-NEXT:    pli r4, 3567587329
 ; CHECK-P10-NEXT:    rldimi r4, r3, 32, 0
 ; CHECK-P10-NEXT:    lfd f0, 0(r4)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 56
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_cst_unalign64_uint8_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    li r3, 29
 ; CHECK-P9-NEXT:    rldic r3, r3, 35, 24
 ; CHECK-P9-NEXT:    oris r3, r3, 54437
 ; CHECK-P9-NEXT:    ori r3, r3, 4097
 ; CHECK-P9-NEXT:    lfd f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 56
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_cst_unalign64_uint8_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    li r3, 29
 ; CHECK-P8-NEXT:    rldic r3, r3, 35, 24
 ; CHECK-P8-NEXT:    oris r3, r3, 54437
 ; CHECK-P8-NEXT:    ori r3, r3, 4097
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 56
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = load double, double* inttoptr (i64 1000000000001 to double*), align 8
   %conv = fptoui double %0 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: norecurse nounwind readonly uwtable willreturn
 define dso_local zeroext i8 @ld_cst_align64_uint8_t_double() {
 ; CHECK-P10-LABEL: ld_cst_align64_uint8_t_double:
 ; CHECK-P10:       # %bb.0: # %entry
 ; CHECK-P10-NEXT:    pli r3, 244140625
 ; CHECK-P10-NEXT:    rldic r3, r3, 12, 24
 ; CHECK-P10-NEXT:    lfd f0, 0(r3)
 ; CHECK-P10-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P10-NEXT:    mffprwz r3, f0
-; CHECK-P10-NEXT:    clrldi r3, r3, 32
+; CHECK-P10-NEXT:    clrldi r3, r3, 56
 ; CHECK-P10-NEXT:    blr
 ;
 ; CHECK-P9-LABEL: ld_cst_align64_uint8_t_double:
 ; CHECK-P9:       # %bb.0: # %entry
 ; CHECK-P9-NEXT:    lis r3, 3725
 ; CHECK-P9-NEXT:    ori r3, r3, 19025
 ; CHECK-P9-NEXT:    rldic r3, r3, 12, 24
 ; CHECK-P9-NEXT:    lfd f0, 0(r3)
 ; CHECK-P9-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P9-NEXT:    mffprwz r3, f0
-; CHECK-P9-NEXT:    clrldi r3, r3, 32
+; CHECK-P9-NEXT:    clrldi r3, r3, 56
 ; CHECK-P9-NEXT:    blr
 ;
 ; CHECK-P8-LABEL: ld_cst_align64_uint8_t_double:
 ; CHECK-P8:       # %bb.0: # %entry
 ; CHECK-P8-NEXT:    lis r3, 3725
 ; CHECK-P8-NEXT:    ori r3, r3, 19025
 ; CHECK-P8-NEXT:    rldic r3, r3, 12, 24
 ; CHECK-P8-NEXT:    lfdx f0, 0, r3
 ; CHECK-P8-NEXT:    xscvdpsxws f0, f0
 ; CHECK-P8-NEXT:    mffprwz r3, f0
-; CHECK-P8-NEXT:    clrldi r3, r3, 32
+; CHECK-P8-NEXT:    clrldi r3, r3, 56
 ; CHECK-P8-NEXT:    blr
 entry:
   %0 = load double, double* inttoptr (i64 1000000000000 to double*), align 4096
   %conv = fptoui double %0 to i8
   ret i8 %conv
 }
 
 ; Function Attrs: nofree norecurse nounwind uwtable willreturn writeonly

llvm/test/CodeGen/RISCV/rv64d-double-convert.ll

; RV64ID-NEXT:    ret
   ret i32 %1
 }
 
 define signext i32 @sext_fptosi(double %a) nounwind {
 ; RV64ID-LABEL: sext_fptosi:
 ; RV64ID:       # %bb.0:
 ; RV64ID-NEXT:    fmv.d.x ft0, a0
 ; RV64ID-NEXT:    fcvt.l.d a0, ft0, rtz
+; RV64ID-NEXT:    sext.w a0, a0
 ; RV64ID-NEXT:    ret
   %1 = fptosi double %a to i32
   ret i32 %1
 }
 
 define zeroext i32 @zext_fptosi(double %a) nounwind {
 ; RV64ID-LABEL: zext_fptosi:
 ; RV64ID:       # %bb.0:
; RV64ID-NEXT:    ret
   %1 = fptoui double %a to i32
   ret i32 %1
 }
 
 define signext i32 @sext_fptoui(double %a) nounwind {
 ; RV64ID-LABEL: sext_fptoui:
 ; RV64ID:       # %bb.0:
 ; RV64ID-NEXT:    fmv.d.x ft0, a0
-; RV64ID-NEXT:    fcvt.wu.d a0, ft0, rtz
+; RV64ID-NEXT:    fcvt.lu.d a0, ft0, rtz
+; RV64ID-NEXT:    sext.w a0, a0
 ; RV64ID-NEXT:    ret
   %1 = fptoui double %a to i32
   ret i32 %1
 }
 
 define zeroext i32 @zext_fptoui(double %a) nounwind {
 ; RV64ID-LABEL: zext_fptoui:
 ; RV64ID:       # %bb.0:
 ; RV64ID-NEXT:    fmv.d.x ft0, a0
 ; RV64ID-NEXT:    fcvt.lu.d a0, ft0, rtz
+; RV64ID-NEXT:    slli a0, a0, 32
+; RV64ID-NEXT:    srli a0, a0, 32
 ; RV64ID-NEXT:    ret
   %1 = fptoui double %a to i32
   ret i32 %1
 }
 
 define double @uitofp_aext_i32_to_f64(i32 %a) nounwind {
 ; RV64ID-LABEL: uitofp_aext_i32_to_f64:
 ; RV64ID:       # %bb.0:

llvm/test/CodeGen/RISCV/rv64f-float-convert.ll

; RV64IF-NEXT:    ret
   ret i32 %1
 }
 
 define signext i32 @sext_fptosi(float %a) nounwind {
 ; RV64IF-LABEL: sext_fptosi:
 ; RV64IF:       # %bb.0:
 ; RV64IF-NEXT:    fmv.w.x ft0, a0
 ; RV64IF-NEXT:    fcvt.l.s a0, ft0, rtz
+; RV64IF-NEXT:    sext.w a0, a0
 ; RV64IF-NEXT:    ret
   %1 = fptosi float %a to i32
   ret i32 %1
 }
 
 define zeroext i32 @zext_fptosi(float %a) nounwind {
 ; RV64IF-LABEL: zext_fptosi:
 ; RV64IF:       # %bb.0:
; RV64IF-NEXT:    ret
   %1 = fptoui float %a to i32
   ret i32 %1
 }
 
 define signext i32 @sext_fptoui(float %a) nounwind {
 ; RV64IF-LABEL: sext_fptoui:
 ; RV64IF:       # %bb.0:
 ; RV64IF-NEXT:    fmv.w.x ft0, a0
-; RV64IF-NEXT:    fcvt.wu.s a0, ft0, rtz
+; RV64IF-NEXT:    fcvt.lu.s a0, ft0, rtz
+; RV64IF-NEXT:    sext.w a0, a0
 ; RV64IF-NEXT:    ret
   %1 = fptoui float %a to i32
   ret i32 %1
 }
 
 define zeroext i32 @zext_fptoui(float %a) nounwind {
 ; RV64IF-LABEL: zext_fptoui:
 ; RV64IF:       # %bb.0:
 ; RV64IF-NEXT:    fmv.w.x ft0, a0
 ; RV64IF-NEXT:    fcvt.lu.s a0, ft0, rtz
+; RV64IF-NEXT:    slli a0, a0, 32
+; RV64IF-NEXT:    srli a0, a0, 32
 ; RV64IF-NEXT:    ret
   %1 = fptoui float %a to i32
   ret i32 %1
 }
 
 define i32 @bcvt_f32_to_aext_i32(float %a, float %b) nounwind {
 ; RV64IF-LABEL: bcvt_f32_to_aext_i32:
 ; RV64IF:       # %bb.0:

llvm/test/CodeGen/RISCV/rv64f-half-convert.ll

; RV64IZFH-NEXT:    ret
   %1 = fptosi half %a to i32
   ret i32 %1
 }
 
 define signext i32 @sext_fptosi(half %a) nounwind {
 ; RV64IZFH-LABEL: sext_fptosi:
 ; RV64IZFH:       # %bb.0:
 ; RV64IZFH-NEXT:    fcvt.l.h a0, fa0, rtz
+; RV64IZFH-NEXT:    sext.w a0, a0
 ; RV64IZFH-NEXT:    ret
   %1 = fptosi half %a to i32
   ret i32 %1
 }
 
 define zeroext i32 @zext_fptosi(half %a) nounwind {
 ; RV64IZFH-LABEL: zext_fptosi:
 ; RV64IZFH:       # %bb.0:

 ; RV64IZFH-NEXT:    ret
   %1 = fptoui half %a to i32
   ret i32 %1
 }
 
 define signext i32 @sext_fptoui(half %a) nounwind {
 ; RV64IZFH-LABEL: sext_fptoui:
 ; RV64IZFH:       # %bb.0:
-; RV64IZFH-NEXT:    fcvt.wu.h a0, fa0, rtz
+; RV64IZFH-NEXT:    fcvt.lu.h a0, fa0, rtz
+; RV64IZFH-NEXT:    sext.w a0, a0
 ; RV64IZFH-NEXT:    ret
   %1 = fptoui half %a to i32
   ret i32 %1
 }
 
 define zeroext i32 @zext_fptoui(half %a) nounwind {
 ; RV64IZFH-LABEL: zext_fptoui:
 ; RV64IZFH:       # %bb.0:
 ; RV64IZFH-NEXT:    fcvt.lu.h a0, fa0, rtz
+; RV64IZFH-NEXT:    slli a0, a0, 32
+; RV64IZFH-NEXT:    srli a0, a0, 32
 ; RV64IZFH-NEXT:    ret
   %1 = fptoui half %a to i32
   ret i32 %1
 }
 
 define i16 @bcvt_f16_to_aext_i16(half %a, half %b) nounwind {
 ; RV64IZFH-LABEL: bcvt_f16_to_aext_i16:
 ; RV64IZFH:       # %bb.0:

llvm/test/CodeGen/X86/avx-cvt-2.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=avx | FileCheck %s
 
 ; Check that we generate vector conversion from float to narrower int types
 
 %f32vec_t = type <8 x float>
 %i16vec_t = type <8 x i16>
 %i8vec_t =  type <8 x i8>
 
 define void @fptoui16(%f32vec_t %a, %i16vec_t *%p) {
 ; CHECK-LABEL: fptoui16:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    vcvttps2dq %ymm0, %ymm0
 ; CHECK-NEXT:    vextractf128 $1, %ymm0, %xmm1
-; CHECK-NEXT:    vpackusdw %xmm1, %xmm0, %xmm0
+; CHECK-NEXT:    vmovdqa {{.*#+}} xmm2 = <0,1,4,5,8,9,12,13,u,u,u,u,u,u,u,u>
+; CHECK-NEXT:    vpshufb %xmm2, %xmm1, %xmm1
+; CHECK-NEXT:    vpshufb %xmm2, %xmm0, %xmm0
+; CHECK-NEXT:    vpunpcklqdq {{.*#+}} xmm0 = xmm0[0],xmm1[0]
 ; CHECK-NEXT:    vmovdqa %xmm0, (%rdi)
 ; CHECK-NEXT:    vzeroupper
 ; CHECK-NEXT:    retq
   %b = fptoui %f32vec_t %a to %i16vec_t
   store %i16vec_t %b, %i16vec_t * %p
   ret void
 }
 
 define void @fptosi16(%f32vec_t %a, %i16vec_t *%p) {
 ; CHECK-LABEL: fptosi16:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    vcvttps2dq %ymm0, %ymm0
 ; CHECK-NEXT:    vextractf128 $1, %ymm0, %xmm1
-; CHECK-NEXT:    vpackssdw %xmm1, %xmm0, %xmm0
+; CHECK-NEXT:    vmovdqa {{.*#+}} xmm2 = <0,1,4,5,8,9,12,13,u,u,u,u,u,u,u,u>
+; CHECK-NEXT:    vpshufb %xmm2, %xmm1, %xmm1
+; CHECK-NEXT:    vpshufb %xmm2, %xmm0, %xmm0
+; CHECK-NEXT:    vpunpcklqdq {{.*#+}} xmm0 = xmm0[0],xmm1[0]
 ; CHECK-NEXT:    vmovdqa %xmm0, (%rdi)
 ; CHECK-NEXT:    vzeroupper
 ; CHECK-NEXT:    retq
   %b = fptosi %f32vec_t %a to %i16vec_t
   store %i16vec_t %b, %i16vec_t * %p
   ret void
 }
 
 define void @fptoui8(%f32vec_t %a, %i8vec_t *%p) {
 ; CHECK-LABEL: fptoui8:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    vcvttps2dq %ymm0, %ymm0
 ; CHECK-NEXT:    vextractf128 $1, %ymm0, %xmm1
-; CHECK-NEXT:    vpackssdw %xmm1, %xmm0, %xmm0
-; CHECK-NEXT:    vpackuswb %xmm0, %xmm0, %xmm0
+; CHECK-NEXT:    vmovdqa {{.*#+}} xmm2 = <0,4,8,12,u,u,u,u,u,u,u,u,u,u,u,u>
+; CHECK-NEXT:    vpshufb %xmm2, %xmm1, %xmm1
+; CHECK-NEXT:    vpshufb %xmm2, %xmm0, %xmm0
+; CHECK-NEXT:    vpunpckldq {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
 ; CHECK-NEXT:    vmovq %xmm0, (%rdi)
 ; CHECK-NEXT:    vzeroupper
 ; CHECK-NEXT:    retq
   %b = fptoui %f32vec_t %a to %i8vec_t
   store %i8vec_t %b, %i8vec_t * %p
   ret void
 }
 
 define void @fptosi8(%f32vec_t %a, %i8vec_t *%p) {
 ; CHECK-LABEL: fptosi8:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    vcvttps2dq %ymm0, %ymm0
 ; CHECK-NEXT:    vextractf128 $1, %ymm0, %xmm1
-; CHECK-NEXT:    vpackssdw %xmm1, %xmm0, %xmm0
-; CHECK-NEXT:    vpacksswb %xmm0, %xmm0, %xmm0
+; CHECK-NEXT:    vmovdqa {{.*#+}} xmm2 = <0,4,8,12,u,u,u,u,u,u,u,u,u,u,u,u>
+; CHECK-NEXT:    vpshufb %xmm2, %xmm1, %xmm1
+; CHECK-NEXT:    vpshufb %xmm2, %xmm0, %xmm0
+; CHECK-NEXT:    vpunpckldq {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
 ; CHECK-NEXT:    vmovq %xmm0, (%rdi)
 ; CHECK-NEXT:    vzeroupper
 ; CHECK-NEXT:    retq
   %b = fptosi %f32vec_t %a to %i8vec_t
   store %i8vec_t %b, %i8vec_t * %p
   ret void
 }

llvm/test/CodeGen/X86/avx-fp2int.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc < %s -mtriple=i386-apple-darwin10 -mcpu=corei7-avx -mattr=+avx | FileCheck %s
 
 ;; Check that FP_TO_SINT and FP_TO_UINT generate convert with truncate
 
 define <4 x i8> @test1(<4 x double> %d) {
 ; CHECK-LABEL: test1:
 ; CHECK:       ## %bb.0:
 ; CHECK-NEXT:    vcvttpd2dq %ymm0, %xmm0
-; CHECK-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
-; CHECK-NEXT:    vpackuswb %xmm0, %xmm0, %xmm0
+; CHECK-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,8,12,u,u,u,u,u,u,u,u,u,u,u,u]
 ; CHECK-NEXT:    vzeroupper
 ; CHECK-NEXT:    retl
   %c = fptoui <4 x double> %d to <4 x i8>
   ret <4 x i8> %c
 }
 define <4 x i8> @test2(<4 x double> %d) {
 ; CHECK-LABEL: test2:
 ; CHECK:       ## %bb.0:
 ; CHECK-NEXT:    vcvttpd2dq %ymm0, %xmm0
-; CHECK-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
-; CHECK-NEXT:    vpacksswb %xmm0, %xmm0, %xmm0
+; CHECK-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,8,12,u,u,u,u,u,u,u,u,u,u,u,u]
 ; CHECK-NEXT:    vzeroupper
 ; CHECK-NEXT:    retl
   %c = fptosi <4 x double> %d to <4 x i8>
   ret <4 x i8> %c
 }

llvm/test/CodeGen/X86/avx512-cvt.ll

; DQNOVL-NEXT:    retq
   ret <2 x i64> %select
 }
 
 define <4 x i64> @test_4f64tosb(<4 x double> %a, <4 x i64> %passthru) {
 ; NOVLDQ-LABEL: test_4f64tosb:
 ; NOVLDQ:       # %bb.0:
 ; NOVLDQ-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; NOVLDQ-NEXT:    vcvttpd2dq %ymm0, %xmm0
+; NOVLDQ-NEXT:    vpslld $31, %xmm0, %xmm0
 ; NOVLDQ-NEXT:    vptestmd %zmm0, %zmm0, %k1
 ; NOVLDQ-NEXT:    vmovdqa64 %zmm1, %zmm0 {%k1} {z}
 ; NOVLDQ-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; NOVLDQ-NEXT:    retq
 ;
 ; VLDQ-LABEL: test_4f64tosb:
 ; VLDQ:       # %bb.0:
 ; VLDQ-NEXT:    vcvttpd2dq %ymm0, %xmm0
+; VLDQ-NEXT:    vpslld $31, %xmm0, %xmm0
 ; VLDQ-NEXT:    vpmovd2m %xmm0, %k1
 ; VLDQ-NEXT:    vmovdqa64 %ymm1, %ymm0 {%k1} {z}
 ; VLDQ-NEXT:    retq
 ;
 ; VLNODQ-LABEL: test_4f64tosb:
 ; VLNODQ:       # %bb.0:
 ; VLNODQ-NEXT:    vcvttpd2dq %ymm0, %xmm0
+; VLNODQ-NEXT:    vpslld $31, %xmm0, %xmm0
 ; VLNODQ-NEXT:    vptestmd %xmm0, %xmm0, %k1
 ; VLNODQ-NEXT:    vmovdqa64 %ymm1, %ymm0 {%k1} {z}
 ; VLNODQ-NEXT:    retq
 ;
 ; DQNOVL-LABEL: test_4f64tosb:
 ; DQNOVL:       # %bb.0:
 ; DQNOVL-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; DQNOVL-NEXT:    vcvttpd2dq %ymm0, %xmm0
+; DQNOVL-NEXT:    vpslld $31, %xmm0, %xmm0
 ; DQNOVL-NEXT:    vpmovd2m %zmm0, %k1
 ; DQNOVL-NEXT:    vmovdqa64 %zmm1, %zmm0 {%k1} {z}
 ; DQNOVL-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; DQNOVL-NEXT:    retq
   %mask = fptosi <4 x double> %a to <4 x i1>
   %select = select <4 x i1> %mask, <4 x i64> %passthru, <4 x i64> zeroinitializer
   ret <4 x i64> %select
 }
 
 define <8 x i64> @test_8f64tosb(<8 x double> %a, <8 x i64> %passthru) {
 ; NOVLDQ-LABEL: test_8f64tosb:
 ; NOVLDQ:       # %bb.0:
 ; NOVLDQ-NEXT:    vcvttpd2dq %zmm0, %ymm0
+; NOVLDQ-NEXT:    vpslld $31, %ymm0, %ymm0
 ; NOVLDQ-NEXT:    vptestmd %zmm0, %zmm0, %k1
 ; NOVLDQ-NEXT:    vmovdqa64 %zmm1, %zmm0 {%k1} {z}
 ; NOVLDQ-NEXT:    retq
 ;
 ; VLDQ-LABEL: test_8f64tosb:
 ; VLDQ:       # %bb.0:
 ; VLDQ-NEXT:    vcvttpd2dq %zmm0, %ymm0
+; VLDQ-NEXT:    vpslld $31, %ymm0, %ymm0
 ; VLDQ-NEXT:    vpmovd2m %ymm0, %k1
 ; VLDQ-NEXT:    vmovdqa64 %zmm1, %zmm0 {%k1} {z}
 ; VLDQ-NEXT:    retq
 ;
 ; VLNODQ-LABEL: test_8f64tosb:
 ; VLNODQ:       # %bb.0:
 ; VLNODQ-NEXT:    vcvttpd2dq %zmm0, %ymm0
+; VLNODQ-NEXT:    vpslld $31, %ymm0, %ymm0
 ; VLNODQ-NEXT:    vptestmd %ymm0, %ymm0, %k1
 ; VLNODQ-NEXT:    vmovdqa64 %zmm1, %zmm0 {%k1} {z}
 ; VLNODQ-NEXT:    retq
 ;
 ; DQNOVL-LABEL: test_8f64tosb:
 ; DQNOVL:       # %bb.0:
 ; DQNOVL-NEXT:    vcvttpd2dq %zmm0, %ymm0
+; DQNOVL-NEXT:    vpslld $31, %ymm0, %ymm0
 ; DQNOVL-NEXT:    vpmovd2m %zmm0, %k1
 ; DQNOVL-NEXT:    vmovdqa64 %zmm1, %zmm0 {%k1} {z}
 ; DQNOVL-NEXT:    retq
   %mask = fptosi <8 x double> %a to <8 x i1>
   %select = select <8 x i1> %mask, <8 x i64> %passthru, <8 x i64> zeroinitializer
   ret <8 x i64> %select
 }
 
 define <2 x i64> @test_2f32tosb(<2 x float> %a, <2 x i64> %passthru) {
 ; NOVLDQ-LABEL: test_2f32tosb:
 ; NOVLDQ:       # %bb.0:
 ; NOVLDQ-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; NOVLDQ-NEXT:    vcvttps2dq %xmm0, %xmm0
+; NOVLDQ-NEXT:    vpslld $31, %xmm0, %xmm0
 ; NOVLDQ-NEXT:    vptestmd %zmm0, %zmm0, %k1
 ; NOVLDQ-NEXT:    vmovdqa64 %zmm1, %zmm0 {%k1} {z}
 ; NOVLDQ-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; NOVLDQ-NEXT:    vzeroupper
 ; NOVLDQ-NEXT:    retq
 ;
 ; VLDQ-LABEL: test_2f32tosb:
 ; VLDQ:       # %bb.0:
 ; VLDQ-NEXT:    vcvttps2dq %xmm0, %xmm0
+; VLDQ-NEXT:    vpslld $31, %xmm0, %xmm0
 ; VLDQ-NEXT:    vpmovd2m %xmm0, %k1
 ; VLDQ-NEXT:    vmovdqa64 %xmm1, %xmm0 {%k1} {z}
 ; VLDQ-NEXT:    retq
 ;
 ; VLNODQ-LABEL: test_2f32tosb:
 ; VLNODQ:       # %bb.0:
 ; VLNODQ-NEXT:    vcvttps2dq %xmm0, %xmm0
+; VLNODQ-NEXT:    vpslld $31, %xmm0, %xmm0
 ; VLNODQ-NEXT:    vptestmd %xmm0, %xmm0, %k1
 ; VLNODQ-NEXT:    vmovdqa64 %xmm1, %xmm0 {%k1} {z}
 ; VLNODQ-NEXT:    retq
 ;
 ; DQNOVL-LABEL: test_2f32tosb:
 ; DQNOVL:       # %bb.0:
 ; DQNOVL-NEXT:    # kill: def $xmm1 killed $xmm1 def $zmm1
 ; DQNOVL-NEXT:    vcvttps2dq %xmm0, %xmm0
+; DQNOVL-NEXT:    vpslld $31, %xmm0, %xmm0
 ; DQNOVL-NEXT:    vpmovd2m %zmm0, %k1
 ; DQNOVL-NEXT:    vmovdqa64 %zmm1, %zmm0 {%k1} {z}
 ; DQNOVL-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; DQNOVL-NEXT:    vzeroupper
 ; DQNOVL-NEXT:    retq
   %mask = fptosi <2 x float> %a to <2 x i1>
   %select = select <2 x i1> %mask, <2 x i64> %passthru, <2 x i64> zeroinitializer
   ret <2 x i64> %select
 }
 
 define <4 x i64> @test_4f32tosb(<4 x float> %a, <4 x i64> %passthru) {
 ; NOVLDQ-LABEL: test_4f32tosb:
 ; NOVLDQ:       # %bb.0:
 ; NOVLDQ-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; NOVLDQ-NEXT:    vcvttps2dq %xmm0, %xmm0
+; NOVLDQ-NEXT:    vpslld $31, %xmm0, %xmm0
 ; NOVLDQ-NEXT:    vptestmd %zmm0, %zmm0, %k1
 ; NOVLDQ-NEXT:    vmovdqa64 %zmm1, %zmm0 {%k1} {z}
 ; NOVLDQ-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; NOVLDQ-NEXT:    retq
 ;
 ; VLDQ-LABEL: test_4f32tosb:
 ; VLDQ:       # %bb.0:
 ; VLDQ-NEXT:    vcvttps2dq %xmm0, %xmm0
+; VLDQ-NEXT:    vpslld $31, %xmm0, %xmm0
 ; VLDQ-NEXT:    vpmovd2m %xmm0, %k1
 ; VLDQ-NEXT:    vmovdqa64 %ymm1, %ymm0 {%k1} {z}
 ; VLDQ-NEXT:    retq
 ;
 ; VLNODQ-LABEL: test_4f32tosb:
 ; VLNODQ:       # %bb.0:
 ; VLNODQ-NEXT:    vcvttps2dq %xmm0, %xmm0
+; VLNODQ-NEXT:    vpslld $31, %xmm0, %xmm0
 ; VLNODQ-NEXT:    vptestmd %xmm0, %xmm0, %k1
 ; VLNODQ-NEXT:    vmovdqa64 %ymm1, %ymm0 {%k1} {z}
 ; VLNODQ-NEXT:    retq
 ;
 ; DQNOVL-LABEL: test_4f32tosb:
 ; DQNOVL:       # %bb.0:
 ; DQNOVL-NEXT:    # kill: def $ymm1 killed $ymm1 def $zmm1
 ; DQNOVL-NEXT:    vcvttps2dq %xmm0, %xmm0
+; DQNOVL-NEXT:    vpslld $31, %xmm0, %xmm0
 ; DQNOVL-NEXT:    vpmovd2m %zmm0, %k1
 ; DQNOVL-NEXT:    vmovdqa64 %zmm1, %zmm0 {%k1} {z}
 ; DQNOVL-NEXT:    # kill: def $ymm0 killed $ymm0 killed $zmm0
 ; DQNOVL-NEXT:    retq
   %mask = fptosi <4 x float> %a to <4 x i1>
   %select = select <4 x i1> %mask, <4 x i64> %passthru, <4 x i64> zeroinitializer
   ret <4 x i64> %select
 }
 
 define <8 x i64> @test_8f32tosb(<8 x float> %a, <8 x i64> %passthru) {
 ; NOVLDQ-LABEL: test_8f32tosb:
 ; NOVLDQ:       # %bb.0:
 ; NOVLDQ-NEXT:    vcvttps2dq %ymm0, %ymm0
+; NOVLDQ-NEXT:    vpslld $31, %ymm0, %ymm0
 ; NOVLDQ-NEXT:    vptestmd %zmm0, %zmm0, %k1
 ; NOVLDQ-NEXT:    vmovdqa64 %zmm1, %zmm0 {%k1} {z}
 ; NOVLDQ-NEXT:    retq
 ;
 ; VLDQ-LABEL: test_8f32tosb:
 ; VLDQ:       # %bb.0:
 ; VLDQ-NEXT:    vcvttps2dq %ymm0, %ymm0
+; VLDQ-NEXT:    vpslld $31, %ymm0, %ymm0
 ; VLDQ-NEXT:    vpmovd2m %ymm0, %k1
 ; VLDQ-NEXT:    vmovdqa64 %zmm1, %zmm0 {%k1} {z}
 ; VLDQ-NEXT:    retq
 ;
 ; VLNODQ-LABEL: test_8f32tosb:
 ; VLNODQ:       # %bb.0:
 ; VLNODQ-NEXT:    vcvttps2dq %ymm0, %ymm0
+; VLNODQ-NEXT:    vpslld $31, %ymm0, %ymm0
 ; VLNODQ-NEXT:    vptestmd %ymm0, %ymm0, %k1
 ; VLNODQ-NEXT:    vmovdqa64 %zmm1, %zmm0 {%k1} {z}
 ; VLNODQ-NEXT:    retq
 ;
 ; DQNOVL-LABEL: test_8f32tosb:
 ; DQNOVL:       # %bb.0:
 ; DQNOVL-NEXT:    vcvttps2dq %ymm0, %ymm0
+; DQNOVL-NEXT:    vpslld $31, %ymm0, %ymm0
 ; DQNOVL-NEXT:    vpmovd2m %zmm0, %k1
 ; DQNOVL-NEXT:    vmovdqa64 %zmm1, %zmm0 {%k1} {z}
 ; DQNOVL-NEXT:    retq
   %mask = fptosi <8 x float> %a to <8 x i1>
   %select = select <8 x i1> %mask, <8 x i64> %passthru, <8 x i64> zeroinitializer
   ret <8 x i64> %select
 }
 
 define <16 x i32> @test_16f32tosb(<16 x float> %a, <16 x i32> %passthru) {
 ; NODQ-LABEL: test_16f32tosb:
 ; NODQ:       # %bb.0:
 ; NODQ-NEXT:    vcvttps2dq %zmm0, %zmm0
+; NODQ-NEXT:    vpslld $31, %zmm0, %zmm0
 ; NODQ-NEXT:    vptestmd %zmm0, %zmm0, %k1
 ; NODQ-NEXT:    vmovdqa32 %zmm1, %zmm0 {%k1} {z}
 ; NODQ-NEXT:    retq
 ;
 ; VLDQ-LABEL: test_16f32tosb:
 ; VLDQ:       # %bb.0:
 ; VLDQ-NEXT:    vcvttps2dq %zmm0, %zmm0
+; VLDQ-NEXT:    vpslld $31, %zmm0, %zmm0
 ; VLDQ-NEXT:    vpmovd2m %zmm0, %k1
 ; VLDQ-NEXT:    vmovdqa32 %zmm1, %zmm0 {%k1} {z}
 ; VLDQ-NEXT:    retq
 ;
 ; DQNOVL-LABEL: test_16f32tosb:
 ; DQNOVL:       # %bb.0:
 ; DQNOVL-NEXT:    vcvttps2dq %zmm0, %zmm0
+; DQNOVL-NEXT:    vpslld $31, %zmm0, %zmm0
 ; DQNOVL-NEXT:    vpmovd2m %zmm0, %k1
 ; DQNOVL-NEXT:    vmovdqa32 %zmm1, %zmm0 {%k1} {z}
 ; DQNOVL-NEXT:    retq
   %mask = fptosi <16 x float> %a to <16 x i1>
   %select = select <16 x i1> %mask, <16 x i32> %passthru, <16 x i32> zeroinitializer
   ret <16 x i32> %select
 }
 

llvm/test/CodeGen/X86/fptoui-may-overflow.ll

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+; RUN: llc < %s -O0 -mtriple=x86_64-unknown-unknown -mattr=avx | FileCheck %s
+
+; We can't only generate "cvttps2dq %xmm0, %xmm0" for this function, because
+; there may be overflow case in fptoui. The old DAG optimization will optimize
+; "%f = fptoui <4 x float> %arg to <4 x i8>" to
+; "%f = fptosi <4 x float> %arg to <4 x i16>" + "AssertZext %f, ValueType:ch:i8"
+; that is not equal when overflow occur in fptoui.
+
+define <16 x i8> @src(<4 x float> %arg) {
+; CHECK-LABEL: src:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    vcvttps2dq %xmm0, %xmm0
+; CHECK-NEXT:    vmovdqa {{.*#+}} xmm1 = [255,0,0,0,255,0,0,0,255,0,0,0,255,0,0,0]
+; CHECK-NEXT:    vpand %xmm1, %xmm0, %xmm0
+; CHECK-NEXT:    retq
+  %f = fptoui <4 x float> %arg to <4 x i8>
+  %s = shufflevector <4 x i8> %f, <4 x i8> undef, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
+  %ss = shufflevector <16 x i8> %s, <16 x i8> zeroinitializer, <16 x i32> <i32 0, i32 17, i32 18, i32 19, i32 1, i32 21, i32 22, i32 23, i32 2, i32 25, i32 26, i32 27, i32 3, i32 29, i32 30, i32 31>
+  ret <16 x i8> %ss
+}

llvm/test/CodeGen/X86/min-legal-vector-width.ll

; CHECK-NEXT:    retq
   %select = select <16 x i1> %mask, <16 x i16> %passthru, <16 x i16> zeroinitializer
   ret <16 x i16> %select
 }
 
 define <16 x i16> @test_16f32tosb_256(<16 x float>* %ptr, <16 x i16> %passthru) "min-legal-vector-width"="256" {
 ; CHECK-LABEL: test_16f32tosb_256:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    vcvttps2dq (%rdi), %ymm1
+; CHECK-NEXT:    vpslld $31, %ymm1, %ymm1
 ; CHECK-NEXT:    vpmovd2m %ymm1, %k0
 ; CHECK-NEXT:    vcvttps2dq 32(%rdi), %ymm1
+; CHECK-NEXT:    vpslld $31, %ymm1, %ymm1
 ; CHECK-NEXT:    vpmovd2m %ymm1, %k1
 ; CHECK-NEXT:    kunpckbw %k0, %k1, %k1
 ; CHECK-NEXT:    vmovdqu16 %ymm0, %ymm0 {%k1} {z}
 ; CHECK-NEXT:    retq
   %a = load <16 x float>, <16 x float>* %ptr
   %mask = fptosi <16 x float> %a to <16 x i1>
   %select = select <16 x i1> %mask, <16 x i16> %passthru, <16 x i16> zeroinitializer
   ret <16 x i16> %select
 }
 
 define <16 x i16> @test_16f32tosb_512(<16 x float>* %ptr, <16 x i16> %passthru) "min-legal-vector-width"="512" {
 ; CHECK-LABEL: test_16f32tosb_512:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    vcvttps2dq (%rdi), %zmm1
+; CHECK-NEXT:    vpslld $31, %zmm1, %zmm1
 ; CHECK-NEXT:    vpmovd2m %zmm1, %k1
 ; CHECK-NEXT:    vmovdqu16 %ymm0, %ymm0 {%k1} {z}
 ; CHECK-NEXT:    retq
   %a = load <16 x float>, <16 x float>* %ptr
   %mask = fptosi <16 x float> %a to <16 x i1>
   %select = select <16 x i1> %mask, <16 x i16> %passthru, <16 x i16> zeroinitializer
   ret <16 x i16> %select
 }

llvm/test/CodeGen/X86/pr48727.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc < %s -mtriple=x86_64-- -mcpu=skx | FileCheck %s
 
 define void @PR48727() {
 ; CHECK-LABEL: PR48727:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    vcvttpd2dqy 0, %xmm0
+; CHECK-NEXT:    vpmovdw %xmm0, %xmm0
 ; CHECK-NEXT:    vcvttpd2dqy 128, %xmm1
-; CHECK-NEXT:    movq (%rax), %rax
+; CHECK-NEXT:    vpmovdw %xmm1, %xmm1
 ; CHECK-NEXT:    vcvttpd2dqy 160, %xmm2
+; CHECK-NEXT:    vpmovdw %xmm2, %xmm2
+; CHECK-NEXT:    movq (%rax), %rax
 ; CHECK-NEXT:    vinserti128 $1, %xmm2, %ymm1, %ymm1
 ; CHECK-NEXT:    vcvttpd2dqy (%rax), %xmm2
+; CHECK-NEXT:    vpmovdw %xmm2, %xmm2
 ; CHECK-NEXT:    vinserti128 $1, %xmm2, %ymm0, %ymm0
-; CHECK-NEXT:    vinserti64x4 $1, %ymm1, %zmm0, %zmm0
-; CHECK-NEXT:    vpmovdw %zmm0, %ymm0
-; CHECK-NEXT:    vmovdqu %ymm0, 16(%rax)
+; CHECK-NEXT:    vmovdqa {{.*#+}} ymm2 = [0,2,4,6]
+; CHECK-NEXT:    vpermi2q %ymm1, %ymm0, %ymm2
+; CHECK-NEXT:    vmovdqu %ymm2, 16(%rax)
 ; CHECK-NEXT:    vzeroupper
 ; CHECK-NEXT:    retq
 entry:
   %0 = load [100 x [100 x i16]]*, [100 x [100 x i16]]** undef, align 8
   %wide.load.2 = load <4 x double>, <4 x double>* null, align 16
   %1 = fptosi <4 x double> %wide.load.2 to <4 x i16>
   %2 = getelementptr inbounds [100 x [100 x i16]], [100 x [100 x i16]]* %0, i64 0, i64 0, i64 8
   %3 = bitcast i16* %2 to <4 x i16>*

llvm/test/CodeGen/X86/vec-strict-fptoint-128.ll

%ret = call <2 x i32> @llvm.experimental.constrained.fptoui.v2i32.v2f32(<2 x float> %a,
                                               metadata !"fpexcept.strict") #0
   ret <2 x i32> %ret
 }
 
 define <2 x i16> @strict_vector_fptosi_v2f64_to_v2i16(<2 x double> %a) #0 {
 ; SSE-32-LABEL: strict_vector_fptosi_v2f64_to_v2i16:
 ; SSE-32:       # %bb.0:
 ; SSE-32-NEXT:    cvttpd2dq %xmm0, %xmm0
-; SSE-32-NEXT:    packssdw %xmm0, %xmm0
+; SSE-32-NEXT:    pshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; SSE-32-NEXT:    retl
 ;
 ; SSE-64-LABEL: strict_vector_fptosi_v2f64_to_v2i16:
 ; SSE-64:       # %bb.0:
 ; SSE-64-NEXT:    cvttpd2dq %xmm0, %xmm0
-; SSE-64-NEXT:    packssdw %xmm0, %xmm0
+; SSE-64-NEXT:    pshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; SSE-64-NEXT:    retq
 ;
 ; AVX-LABEL: strict_vector_fptosi_v2f64_to_v2i16:
 ; AVX:       # %bb.0:
 ; AVX-NEXT:    vcvttpd2dq %xmm0, %xmm0
-; AVX-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
+; AVX-NEXT:    vpshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; AVX-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512F-LABEL: strict_vector_fptosi_v2f64_to_v2i16:
 ; AVX512F:       # %bb.0:
 ; AVX512F-NEXT:    vcvttpd2dq %xmm0, %xmm0
-; AVX512F-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
+; AVX512F-NEXT:    vpshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; AVX512F-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512VL-LABEL: strict_vector_fptosi_v2f64_to_v2i16:
 ; AVX512VL:       # %bb.0:
 ; AVX512VL-NEXT:    vcvttpd2dq %xmm0, %xmm0
-; AVX512VL-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
+; AVX512VL-NEXT:    vpshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; AVX512VL-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512DQ-LABEL: strict_vector_fptosi_v2f64_to_v2i16:
 ; AVX512DQ:       # %bb.0:
 ; AVX512DQ-NEXT:    vcvttpd2dq %xmm0, %xmm0
-; AVX512DQ-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
+; AVX512DQ-NEXT:    vpshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; AVX512DQ-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512VLDQ-LABEL: strict_vector_fptosi_v2f64_to_v2i16:
 ; AVX512VLDQ:       # %bb.0:
 ; AVX512VLDQ-NEXT:    vcvttpd2dq %xmm0, %xmm0
-; AVX512VLDQ-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
+; AVX512VLDQ-NEXT:    vpshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; AVX512VLDQ-NEXT:    ret{{[l|q]}}
   %ret = call <2 x i16> @llvm.experimental.constrained.fptosi.v2i16.v2f64(<2 x double> %a,
                                               metadata !"fpexcept.strict") #0
   ret <2 x i16> %ret
 }
 
 define <2 x i16> @strict_vector_fptoui_v2f64_to_v2i16(<2 x double> %a) #0 {
 ; SSE-32-LABEL: strict_vector_fptoui_v2f64_to_v2i16:
 ; SSE-32:       # %bb.0:
 ; SSE-32-NEXT:    cvttpd2dq %xmm0, %xmm0
 ; SSE-32-NEXT:    pshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; SSE-32-NEXT:    retl
 ;
 ; SSE-64-LABEL: strict_vector_fptoui_v2f64_to_v2i16:
 ; SSE-64:       # %bb.0:
 ; SSE-64-NEXT:    cvttpd2dq %xmm0, %xmm0
 ; SSE-64-NEXT:    pshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; SSE-64-NEXT:    retq
 ;
 ; AVX-LABEL: strict_vector_fptoui_v2f64_to_v2i16:
 ; AVX:       # %bb.0:
 ; AVX-NEXT:    vcvttpd2dq %xmm0, %xmm0
-; AVX-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
+; AVX-NEXT:    vpshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; AVX-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512F-LABEL: strict_vector_fptoui_v2f64_to_v2i16:
 ; AVX512F:       # %bb.0:
 ; AVX512F-NEXT:    vcvttpd2dq %xmm0, %xmm0
-; AVX512F-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
+; AVX512F-NEXT:    vpshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; AVX512F-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512VL-LABEL: strict_vector_fptoui_v2f64_to_v2i16:
 ; AVX512VL:       # %bb.0:
 ; AVX512VL-NEXT:    vcvttpd2dq %xmm0, %xmm0
-; AVX512VL-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
+; AVX512VL-NEXT:    vpshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; AVX512VL-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512DQ-LABEL: strict_vector_fptoui_v2f64_to_v2i16:
 ; AVX512DQ:       # %bb.0:
 ; AVX512DQ-NEXT:    vcvttpd2dq %xmm0, %xmm0
-; AVX512DQ-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
+; AVX512DQ-NEXT:    vpshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; AVX512DQ-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512VLDQ-LABEL: strict_vector_fptoui_v2f64_to_v2i16:
 ; AVX512VLDQ:       # %bb.0:
 ; AVX512VLDQ-NEXT:    vcvttpd2dq %xmm0, %xmm0
-; AVX512VLDQ-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
+; AVX512VLDQ-NEXT:    vpshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; AVX512VLDQ-NEXT:    ret{{[l|q]}}
   %ret = call <2 x i16> @llvm.experimental.constrained.fptoui.v2i16.v2f64(<2 x double> %a,
                                               metadata !"fpexcept.strict") #0
   ret <2 x i16> %ret
 }
 
 define <2 x i16> @strict_vector_fptosi_v2f32_to_v2i16(<2 x float> %a) #0 {
 ; SSE-32-LABEL: strict_vector_fptosi_v2f32_to_v2i16:
 ; SSE-32:       # %bb.0:
 ; SSE-32-NEXT:    movq {{.*#+}} xmm0 = xmm0[0],zero
 ; SSE-32-NEXT:    cvttps2dq %xmm0, %xmm0
-; SSE-32-NEXT:    packssdw %xmm0, %xmm0
+; SSE-32-NEXT:    pshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; SSE-32-NEXT:    retl
 ;
 ; SSE-64-LABEL: strict_vector_fptosi_v2f32_to_v2i16:
 ; SSE-64:       # %bb.0:
 ; SSE-64-NEXT:    movq {{.*#+}} xmm0 = xmm0[0],zero
 ; SSE-64-NEXT:    cvttps2dq %xmm0, %xmm0
-; SSE-64-NEXT:    packssdw %xmm0, %xmm0
+; SSE-64-NEXT:    pshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; SSE-64-NEXT:    retq
 ;
 ; AVX-LABEL: strict_vector_fptosi_v2f32_to_v2i16:
 ; AVX:       # %bb.0:
 ; AVX-NEXT:    vmovq {{.*#+}} xmm0 = xmm0[0],zero
 ; AVX-NEXT:    vcvttps2dq %xmm0, %xmm0
-; AVX-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
+; AVX-NEXT:    vpshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; AVX-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512F-LABEL: strict_vector_fptosi_v2f32_to_v2i16:
 ; AVX512F:       # %bb.0:
 ; AVX512F-NEXT:    vmovq {{.*#+}} xmm0 = xmm0[0],zero
 ; AVX512F-NEXT:    vcvttps2dq %xmm0, %xmm0
-; AVX512F-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
+; AVX512F-NEXT:    vpshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; AVX512F-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512VL-LABEL: strict_vector_fptosi_v2f32_to_v2i16:
 ; AVX512VL:       # %bb.0:
 ; AVX512VL-NEXT:    vmovq {{.*#+}} xmm0 = xmm0[0],zero
 ; AVX512VL-NEXT:    vcvttps2dq %xmm0, %xmm0
-; AVX512VL-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
+; AVX512VL-NEXT:    vpshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; AVX512VL-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512DQ-LABEL: strict_vector_fptosi_v2f32_to_v2i16:
 ; AVX512DQ:       # %bb.0:
 ; AVX512DQ-NEXT:    vmovq {{.*#+}} xmm0 = xmm0[0],zero
 ; AVX512DQ-NEXT:    vcvttps2dq %xmm0, %xmm0
-; AVX512DQ-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
+; AVX512DQ-NEXT:    vpshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; AVX512DQ-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512VLDQ-LABEL: strict_vector_fptosi_v2f32_to_v2i16:
 ; AVX512VLDQ:       # %bb.0:
 ; AVX512VLDQ-NEXT:    vmovq {{.*#+}} xmm0 = xmm0[0],zero
 ; AVX512VLDQ-NEXT:    vcvttps2dq %xmm0, %xmm0
-; AVX512VLDQ-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
+; AVX512VLDQ-NEXT:    vpshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; AVX512VLDQ-NEXT:    ret{{[l|q]}}
   %ret = call <2 x i16> @llvm.experimental.constrained.fptosi.v2i16.v2f32(<2 x float> %a,
                                               metadata !"fpexcept.strict") #0
   ret <2 x i16> %ret
 }
 
 define <2 x i16> @strict_vector_fptoui_v2f32_to_v2i16(<2 x float> %a) #0 {
 ; SSE-32-LABEL: strict_vector_fptoui_v2f32_to_v2i16:

 ; SSE-64-NEXT:    cvttps2dq %xmm0, %xmm0
 ; SSE-64-NEXT:    pshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; SSE-64-NEXT:    retq
 ;
 ; AVX-LABEL: strict_vector_fptoui_v2f32_to_v2i16:
 ; AVX:       # %bb.0:
 ; AVX-NEXT:    vmovq {{.*#+}} xmm0 = xmm0[0],zero
 ; AVX-NEXT:    vcvttps2dq %xmm0, %xmm0
-; AVX-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
+; AVX-NEXT:    vpshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; AVX-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512F-LABEL: strict_vector_fptoui_v2f32_to_v2i16:
 ; AVX512F:       # %bb.0:
 ; AVX512F-NEXT:    vmovq {{.*#+}} xmm0 = xmm0[0],zero
 ; AVX512F-NEXT:    vcvttps2dq %xmm0, %xmm0
-; AVX512F-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
+; AVX512F-NEXT:    vpshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; AVX512F-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512VL-LABEL: strict_vector_fptoui_v2f32_to_v2i16:
 ; AVX512VL:       # %bb.0:
 ; AVX512VL-NEXT:    vmovq {{.*#+}} xmm0 = xmm0[0],zero
 ; AVX512VL-NEXT:    vcvttps2dq %xmm0, %xmm0
-; AVX512VL-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
+; AVX512VL-NEXT:    vpshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; AVX512VL-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512DQ-LABEL: strict_vector_fptoui_v2f32_to_v2i16:
 ; AVX512DQ:       # %bb.0:
 ; AVX512DQ-NEXT:    vmovq {{.*#+}} xmm0 = xmm0[0],zero
 ; AVX512DQ-NEXT:    vcvttps2dq %xmm0, %xmm0
-; AVX512DQ-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
+; AVX512DQ-NEXT:    vpshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; AVX512DQ-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512VLDQ-LABEL: strict_vector_fptoui_v2f32_to_v2i16:
 ; AVX512VLDQ:       # %bb.0:
 ; AVX512VLDQ-NEXT:    vmovq {{.*#+}} xmm0 = xmm0[0],zero
 ; AVX512VLDQ-NEXT:    vcvttps2dq %xmm0, %xmm0
-; AVX512VLDQ-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
+; AVX512VLDQ-NEXT:    vpshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; AVX512VLDQ-NEXT:    ret{{[l|q]}}
   %ret = call <2 x i16> @llvm.experimental.constrained.fptoui.v2i16.v2f32(<2 x float> %a,
                                               metadata !"fpexcept.strict") #0
   ret <2 x i16> %ret
 }
 
 define <2 x i8> @strict_vector_fptosi_v2f64_to_v2i8(<2 x double> %a) #0 {
 ; SSE-32-LABEL: strict_vector_fptosi_v2f64_to_v2i8:
 ; SSE-32:       # %bb.0:
 ; SSE-32-NEXT:    cvttpd2dq %xmm0, %xmm0
-; SSE-32-NEXT:    packssdw %xmm0, %xmm0
-; SSE-32-NEXT:    packsswb %xmm0, %xmm0
+; SSE-32-NEXT:    andpd {{\.?LCPI[0-9]+_[0-9]+}}, %xmm0
+; SSE-32-NEXT:    packuswb %xmm0, %xmm0
+; SSE-32-NEXT:    packuswb %xmm0, %xmm0
 ; SSE-32-NEXT:    retl
 ;
 ; SSE-64-LABEL: strict_vector_fptosi_v2f64_to_v2i8:
 ; SSE-64:       # %bb.0:
 ; SSE-64-NEXT:    cvttpd2dq %xmm0, %xmm0
-; SSE-64-NEXT:    packssdw %xmm0, %xmm0
-; SSE-64-NEXT:    packsswb %xmm0, %xmm0
+; SSE-64-NEXT:    andpd {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0
+; SSE-64-NEXT:    packuswb %xmm0, %xmm0
+; SSE-64-NEXT:    packuswb %xmm0, %xmm0
 ; SSE-64-NEXT:    retq
 ;
 ; AVX-LABEL: strict_vector_fptosi_v2f64_to_v2i8:
 ; AVX:       # %bb.0:
 ; AVX-NEXT:    vcvttpd2dq %xmm0, %xmm0
-; AVX-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
-; AVX-NEXT:    vpacksswb %xmm0, %xmm0, %xmm0
+; AVX-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,u,u,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512F-LABEL: strict_vector_fptosi_v2f64_to_v2i8:
 ; AVX512F:       # %bb.0:
 ; AVX512F-NEXT:    vcvttpd2dq %xmm0, %xmm0
-; AVX512F-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
-; AVX512F-NEXT:    vpacksswb %xmm0, %xmm0, %xmm0
+; AVX512F-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,u,u,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX512F-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512VL-LABEL: strict_vector_fptosi_v2f64_to_v2i8:
 ; AVX512VL:       # %bb.0:
 ; AVX512VL-NEXT:    vcvttpd2dq %xmm0, %xmm0
 ; AVX512VL-NEXT:    vpmovdb %xmm0, %xmm0
 ; AVX512VL-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512DQ-LABEL: strict_vector_fptosi_v2f64_to_v2i8:
 ; AVX512DQ:       # %bb.0:
 ; AVX512DQ-NEXT:    vcvttpd2dq %xmm0, %xmm0
-; AVX512DQ-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
-; AVX512DQ-NEXT:    vpacksswb %xmm0, %xmm0, %xmm0
+; AVX512DQ-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,u,u,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX512DQ-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512VLDQ-LABEL: strict_vector_fptosi_v2f64_to_v2i8:
 ; AVX512VLDQ:       # %bb.0:
 ; AVX512VLDQ-NEXT:    vcvttpd2dq %xmm0, %xmm0
 ; AVX512VLDQ-NEXT:    vpmovdb %xmm0, %xmm0
 ; AVX512VLDQ-NEXT:    ret{{[l|q]}}
   %ret = call <2 x i8> @llvm.experimental.constrained.fptosi.v2i8.v2f64(<2 x double> %a,
                                               metadata !"fpexcept.strict") #0
   ret <2 x i8> %ret
 }
 
 define <2 x i8> @strict_vector_fptoui_v2f64_to_v2i8(<2 x double> %a) #0 {
 ; SSE-32-LABEL: strict_vector_fptoui_v2f64_to_v2i8:
 ; SSE-32:       # %bb.0:
 ; SSE-32-NEXT:    cvttpd2dq %xmm0, %xmm0
+; SSE-32-NEXT:    andpd {{\.?LCPI[0-9]+_[0-9]+}}, %xmm0
 ; SSE-32-NEXT:    packuswb %xmm0, %xmm0
 ; SSE-32-NEXT:    packuswb %xmm0, %xmm0
 ; SSE-32-NEXT:    retl
 ;
 ; SSE-64-LABEL: strict_vector_fptoui_v2f64_to_v2i8:
 ; SSE-64:       # %bb.0:
 ; SSE-64-NEXT:    cvttpd2dq %xmm0, %xmm0
+; SSE-64-NEXT:    andpd {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0
 ; SSE-64-NEXT:    packuswb %xmm0, %xmm0
 ; SSE-64-NEXT:    packuswb %xmm0, %xmm0
 ; SSE-64-NEXT:    retq
 ;
 ; AVX-LABEL: strict_vector_fptoui_v2f64_to_v2i8:
 ; AVX:       # %bb.0:
 ; AVX-NEXT:    vcvttpd2dq %xmm0, %xmm0
-; AVX-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
-; AVX-NEXT:    vpackuswb %xmm0, %xmm0, %xmm0
+; AVX-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,u,u,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512F-LABEL: strict_vector_fptoui_v2f64_to_v2i8:
 ; AVX512F:       # %bb.0:
 ; AVX512F-NEXT:    vcvttpd2dq %xmm0, %xmm0
-; AVX512F-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
-; AVX512F-NEXT:    vpackuswb %xmm0, %xmm0, %xmm0
+; AVX512F-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,u,u,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX512F-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512VL-LABEL: strict_vector_fptoui_v2f64_to_v2i8:
 ; AVX512VL:       # %bb.0:
 ; AVX512VL-NEXT:    vcvttpd2dq %xmm0, %xmm0
 ; AVX512VL-NEXT:    vpmovdb %xmm0, %xmm0
 ; AVX512VL-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512DQ-LABEL: strict_vector_fptoui_v2f64_to_v2i8:
 ; AVX512DQ:       # %bb.0:
 ; AVX512DQ-NEXT:    vcvttpd2dq %xmm0, %xmm0
-; AVX512DQ-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
-; AVX512DQ-NEXT:    vpackuswb %xmm0, %xmm0, %xmm0
+; AVX512DQ-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,u,u,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX512DQ-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512VLDQ-LABEL: strict_vector_fptoui_v2f64_to_v2i8:
 ; AVX512VLDQ:       # %bb.0:
 ; AVX512VLDQ-NEXT:    vcvttpd2dq %xmm0, %xmm0
 ; AVX512VLDQ-NEXT:    vpmovdb %xmm0, %xmm0
 ; AVX512VLDQ-NEXT:    ret{{[l|q]}}
   %ret = call <2 x i8> @llvm.experimental.constrained.fptoui.v2i8.v2f64(<2 x double> %a,
                                               metadata !"fpexcept.strict") #0
   ret <2 x i8> %ret
 }
 
 define <2 x i8> @strict_vector_fptosi_v2f32_to_v2i8(<2 x float> %a) #0 {
 ; SSE-32-LABEL: strict_vector_fptosi_v2f32_to_v2i8:
 ; SSE-32:       # %bb.0:
 ; SSE-32-NEXT:    movq {{.*#+}} xmm0 = xmm0[0],zero
 ; SSE-32-NEXT:    cvttps2dq %xmm0, %xmm0
-; SSE-32-NEXT:    packssdw %xmm0, %xmm0
-; SSE-32-NEXT:    packsswb %xmm0, %xmm0
+; SSE-32-NEXT:    pand {{\.?LCPI[0-9]+_[0-9]+}}, %xmm0
+; SSE-32-NEXT:    packuswb %xmm0, %xmm0
+; SSE-32-NEXT:    packuswb %xmm0, %xmm0
 ; SSE-32-NEXT:    retl
 ;
 ; SSE-64-LABEL: strict_vector_fptosi_v2f32_to_v2i8:
 ; SSE-64:       # %bb.0:
 ; SSE-64-NEXT:    movq {{.*#+}} xmm0 = xmm0[0],zero
 ; SSE-64-NEXT:    cvttps2dq %xmm0, %xmm0
-; SSE-64-NEXT:    packssdw %xmm0, %xmm0
-; SSE-64-NEXT:    packsswb %xmm0, %xmm0
+; SSE-64-NEXT:    pand {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0
+; SSE-64-NEXT:    packuswb %xmm0, %xmm0
+; SSE-64-NEXT:    packuswb %xmm0, %xmm0
 ; SSE-64-NEXT:    retq
 ;
 ; AVX-LABEL: strict_vector_fptosi_v2f32_to_v2i8:
 ; AVX:       # %bb.0:
 ; AVX-NEXT:    vmovq {{.*#+}} xmm0 = xmm0[0],zero
 ; AVX-NEXT:    vcvttps2dq %xmm0, %xmm0
-; AVX-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
-; AVX-NEXT:    vpacksswb %xmm0, %xmm0, %xmm0
+; AVX-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,u,u,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512F-LABEL: strict_vector_fptosi_v2f32_to_v2i8:
 ; AVX512F:       # %bb.0:
 ; AVX512F-NEXT:    vmovq {{.*#+}} xmm0 = xmm0[0],zero
 ; AVX512F-NEXT:    vcvttps2dq %xmm0, %xmm0
-; AVX512F-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
-; AVX512F-NEXT:    vpacksswb %xmm0, %xmm0, %xmm0
+; AVX512F-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,u,u,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX512F-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512VL-LABEL: strict_vector_fptosi_v2f32_to_v2i8:
 ; AVX512VL:       # %bb.0:
 ; AVX512VL-NEXT:    vmovq {{.*#+}} xmm0 = xmm0[0],zero
 ; AVX512VL-NEXT:    vcvttps2dq %xmm0, %xmm0
 ; AVX512VL-NEXT:    vpmovdb %xmm0, %xmm0
 ; AVX512VL-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512DQ-LABEL: strict_vector_fptosi_v2f32_to_v2i8:
 ; AVX512DQ:       # %bb.0:
 ; AVX512DQ-NEXT:    vmovq {{.*#+}} xmm0 = xmm0[0],zero
 ; AVX512DQ-NEXT:    vcvttps2dq %xmm0, %xmm0
-; AVX512DQ-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
-; AVX512DQ-NEXT:    vpacksswb %xmm0, %xmm0, %xmm0
+; AVX512DQ-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,u,u,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX512DQ-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512VLDQ-LABEL: strict_vector_fptosi_v2f32_to_v2i8:
 ; AVX512VLDQ:       # %bb.0:
 ; AVX512VLDQ-NEXT:    vmovq {{.*#+}} xmm0 = xmm0[0],zero
 ; AVX512VLDQ-NEXT:    vcvttps2dq %xmm0, %xmm0
 ; AVX512VLDQ-NEXT:    vpmovdb %xmm0, %xmm0
 ; AVX512VLDQ-NEXT:    ret{{[l|q]}}
   %ret = call <2 x i8> @llvm.experimental.constrained.fptosi.v2i8.v2f32(<2 x float> %a,
                                               metadata !"fpexcept.strict") #0
   ret <2 x i8> %ret
 }
 
 define <2 x i8> @strict_vector_fptoui_v2f32_to_v2i8(<2 x float> %a) #0 {
 ; SSE-32-LABEL: strict_vector_fptoui_v2f32_to_v2i8:
 ; SSE-32:       # %bb.0:
 ; SSE-32-NEXT:    movq {{.*#+}} xmm0 = xmm0[0],zero
 ; SSE-32-NEXT:    cvttps2dq %xmm0, %xmm0
+; SSE-32-NEXT:    pand {{\.?LCPI[0-9]+_[0-9]+}}, %xmm0
 ; SSE-32-NEXT:    packuswb %xmm0, %xmm0
 ; SSE-32-NEXT:    packuswb %xmm0, %xmm0
 ; SSE-32-NEXT:    retl
 ;
 ; SSE-64-LABEL: strict_vector_fptoui_v2f32_to_v2i8:
 ; SSE-64:       # %bb.0:
 ; SSE-64-NEXT:    movq {{.*#+}} xmm0 = xmm0[0],zero
 ; SSE-64-NEXT:    cvttps2dq %xmm0, %xmm0
+; SSE-64-NEXT:    pand {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0
 ; SSE-64-NEXT:    packuswb %xmm0, %xmm0
 ; SSE-64-NEXT:    packuswb %xmm0, %xmm0
 ; SSE-64-NEXT:    retq
 ;
 ; AVX-LABEL: strict_vector_fptoui_v2f32_to_v2i8:
 ; AVX:       # %bb.0:
 ; AVX-NEXT:    vmovq {{.*#+}} xmm0 = xmm0[0],zero
 ; AVX-NEXT:    vcvttps2dq %xmm0, %xmm0
-; AVX-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
-; AVX-NEXT:    vpackuswb %xmm0, %xmm0, %xmm0
+; AVX-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,u,u,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512F-LABEL: strict_vector_fptoui_v2f32_to_v2i8:
 ; AVX512F:       # %bb.0:
 ; AVX512F-NEXT:    vmovq {{.*#+}} xmm0 = xmm0[0],zero
 ; AVX512F-NEXT:    vcvttps2dq %xmm0, %xmm0
-; AVX512F-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
-; AVX512F-NEXT:    vpackuswb %xmm0, %xmm0, %xmm0
+; AVX512F-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,u,u,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX512F-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512VL-LABEL: strict_vector_fptoui_v2f32_to_v2i8:
 ; AVX512VL:       # %bb.0:
 ; AVX512VL-NEXT:    vmovq {{.*#+}} xmm0 = xmm0[0],zero
 ; AVX512VL-NEXT:    vcvttps2dq %xmm0, %xmm0
 ; AVX512VL-NEXT:    vpmovdb %xmm0, %xmm0
 ; AVX512VL-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512DQ-LABEL: strict_vector_fptoui_v2f32_to_v2i8:
 ; AVX512DQ:       # %bb.0:
 ; AVX512DQ-NEXT:    vmovq {{.*#+}} xmm0 = xmm0[0],zero
 ; AVX512DQ-NEXT:    vcvttps2dq %xmm0, %xmm0
-; AVX512DQ-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
-; AVX512DQ-NEXT:    vpackuswb %xmm0, %xmm0, %xmm0
+; AVX512DQ-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,u,u,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX512DQ-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512VLDQ-LABEL: strict_vector_fptoui_v2f32_to_v2i8:
 ; AVX512VLDQ:       # %bb.0:
 ; AVX512VLDQ-NEXT:    vmovq {{.*#+}} xmm0 = xmm0[0],zero
 ; AVX512VLDQ-NEXT:    vcvttps2dq %xmm0, %xmm0
 ; AVX512VLDQ-NEXT:    vpmovdb %xmm0, %xmm0
 ; AVX512VLDQ-NEXT:    ret{{[l|q]}}
%ret = call <4 x i32> @llvm.experimental.constrained.fptoui.v4i32.v4f32(<4 x float> %a,
                                               metadata !"fpexcept.strict") #0
   ret <4 x i32> %ret
 }
 
 define <4 x i8> @strict_vector_fptosi_v4f32_to_v4i8(<4 x float> %a) #0 {
 ; SSE-32-LABEL: strict_vector_fptosi_v4f32_to_v4i8:
 ; SSE-32:       # %bb.0:
 ; SSE-32-NEXT:    cvttps2dq %xmm0, %xmm0
-; SSE-32-NEXT:    packssdw %xmm0, %xmm0
-; SSE-32-NEXT:    packsswb %xmm0, %xmm0
+; SSE-32-NEXT:    pand {{\.?LCPI[0-9]+_[0-9]+}}, %xmm0
+; SSE-32-NEXT:    packuswb %xmm0, %xmm0
+; SSE-32-NEXT:    packuswb %xmm0, %xmm0
 ; SSE-32-NEXT:    retl
 ;
 ; SSE-64-LABEL: strict_vector_fptosi_v4f32_to_v4i8:
 ; SSE-64:       # %bb.0:
 ; SSE-64-NEXT:    cvttps2dq %xmm0, %xmm0
-; SSE-64-NEXT:    packssdw %xmm0, %xmm0
-; SSE-64-NEXT:    packsswb %xmm0, %xmm0
+; SSE-64-NEXT:    pand {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0
+; SSE-64-NEXT:    packuswb %xmm0, %xmm0
+; SSE-64-NEXT:    packuswb %xmm0, %xmm0
 ; SSE-64-NEXT:    retq
 ;
 ; AVX-LABEL: strict_vector_fptosi_v4f32_to_v4i8:
 ; AVX:       # %bb.0:
 ; AVX-NEXT:    vcvttps2dq %xmm0, %xmm0
-; AVX-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
-; AVX-NEXT:    vpacksswb %xmm0, %xmm0, %xmm0
+; AVX-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,8,12,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512F-LABEL: strict_vector_fptosi_v4f32_to_v4i8:
 ; AVX512F:       # %bb.0:
 ; AVX512F-NEXT:    vcvttps2dq %xmm0, %xmm0
-; AVX512F-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
-; AVX512F-NEXT:    vpacksswb %xmm0, %xmm0, %xmm0
+; AVX512F-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,8,12,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX512F-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512VL-LABEL: strict_vector_fptosi_v4f32_to_v4i8:
 ; AVX512VL:       # %bb.0:
 ; AVX512VL-NEXT:    vcvttps2dq %xmm0, %xmm0
 ; AVX512VL-NEXT:    vpmovdb %xmm0, %xmm0
 ; AVX512VL-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512DQ-LABEL: strict_vector_fptosi_v4f32_to_v4i8:
 ; AVX512DQ:       # %bb.0:
 ; AVX512DQ-NEXT:    vcvttps2dq %xmm0, %xmm0
-; AVX512DQ-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
-; AVX512DQ-NEXT:    vpacksswb %xmm0, %xmm0, %xmm0
+; AVX512DQ-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,8,12,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX512DQ-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512VLDQ-LABEL: strict_vector_fptosi_v4f32_to_v4i8:
 ; AVX512VLDQ:       # %bb.0:
 ; AVX512VLDQ-NEXT:    vcvttps2dq %xmm0, %xmm0
 ; AVX512VLDQ-NEXT:    vpmovdb %xmm0, %xmm0
 ; AVX512VLDQ-NEXT:    ret{{[l|q]}}
   %ret = call <4 x i8> @llvm.experimental.constrained.fptosi.v4i8.v4f32(<4 x float> %a,
                                               metadata !"fpexcept.strict") #0
   ret <4 x i8> %ret
 }
 
 define <4 x i8> @strict_vector_fptoui_v4f32_to_v4i8(<4 x float> %a) #0 {
 ; SSE-32-LABEL: strict_vector_fptoui_v4f32_to_v4i8:
 ; SSE-32:       # %bb.0:
 ; SSE-32-NEXT:    cvttps2dq %xmm0, %xmm0
+; SSE-32-NEXT:    pand {{\.?LCPI[0-9]+_[0-9]+}}, %xmm0
 ; SSE-32-NEXT:    packuswb %xmm0, %xmm0
 ; SSE-32-NEXT:    packuswb %xmm0, %xmm0
 ; SSE-32-NEXT:    retl
 ;
 ; SSE-64-LABEL: strict_vector_fptoui_v4f32_to_v4i8:
 ; SSE-64:       # %bb.0:
 ; SSE-64-NEXT:    cvttps2dq %xmm0, %xmm0
+; SSE-64-NEXT:    pand {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0
 ; SSE-64-NEXT:    packuswb %xmm0, %xmm0
 ; SSE-64-NEXT:    packuswb %xmm0, %xmm0
 ; SSE-64-NEXT:    retq
 ;
 ; AVX-LABEL: strict_vector_fptoui_v4f32_to_v4i8:
 ; AVX:       # %bb.0:
 ; AVX-NEXT:    vcvttps2dq %xmm0, %xmm0
-; AVX-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
-; AVX-NEXT:    vpackuswb %xmm0, %xmm0, %xmm0
+; AVX-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,8,12,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512F-LABEL: strict_vector_fptoui_v4f32_to_v4i8:
 ; AVX512F:       # %bb.0:
 ; AVX512F-NEXT:    vcvttps2dq %xmm0, %xmm0
-; AVX512F-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
-; AVX512F-NEXT:    vpackuswb %xmm0, %xmm0, %xmm0
+; AVX512F-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,8,12,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX512F-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512VL-LABEL: strict_vector_fptoui_v4f32_to_v4i8:
 ; AVX512VL:       # %bb.0:
 ; AVX512VL-NEXT:    vcvttps2dq %xmm0, %xmm0
 ; AVX512VL-NEXT:    vpmovdb %xmm0, %xmm0
 ; AVX512VL-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512DQ-LABEL: strict_vector_fptoui_v4f32_to_v4i8:
 ; AVX512DQ:       # %bb.0:
 ; AVX512DQ-NEXT:    vcvttps2dq %xmm0, %xmm0
-; AVX512DQ-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
-; AVX512DQ-NEXT:    vpackuswb %xmm0, %xmm0, %xmm0
+; AVX512DQ-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,8,12,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX512DQ-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512VLDQ-LABEL: strict_vector_fptoui_v4f32_to_v4i8:
 ; AVX512VLDQ:       # %bb.0:
 ; AVX512VLDQ-NEXT:    vcvttps2dq %xmm0, %xmm0
 ; AVX512VLDQ-NEXT:    vpmovdb %xmm0, %xmm0
 ; AVX512VLDQ-NEXT:    ret{{[l|q]}}
   %ret = call <4 x i8> @llvm.experimental.constrained.fptoui.v4i8.v4f32(<4 x float> %a,

 ; AVX-LABEL: strict_vector_fptosi_v4f32_to_v4i1:
 ; AVX:       # %bb.0:
 ; AVX-NEXT:    vcvttps2dq %xmm0, %xmm0
 ; AVX-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512F-LABEL: strict_vector_fptosi_v4f32_to_v4i1:
 ; AVX512F:       # %bb.0:
 ; AVX512F-NEXT:    vcvttps2dq %xmm0, %xmm0
+; AVX512F-NEXT:    vpslld $31, %xmm0, %xmm0
 ; AVX512F-NEXT:    vptestmd %zmm0, %zmm0, %k1
 ; AVX512F-NEXT:    vpternlogd $255, %zmm0, %zmm0, %zmm0 {%k1} {z}
 ; AVX512F-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-NEXT:    vzeroupper
 ; AVX512F-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512VL-LABEL: strict_vector_fptosi_v4f32_to_v4i1:
 ; AVX512VL:       # %bb.0:
 ; AVX512VL-NEXT:    vcvttps2dq %xmm0, %xmm0
+; AVX512VL-NEXT:    vpslld $31, %xmm0, %xmm0
 ; AVX512VL-NEXT:    vptestmd %xmm0, %xmm0, %k1
 ; AVX512VL-NEXT:    vpcmpeqd %xmm0, %xmm0, %xmm0
 ; AVX512VL-NEXT:    vmovdqa32 %xmm0, %xmm0 {%k1} {z}
 ; AVX512VL-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512DQ-LABEL: strict_vector_fptosi_v4f32_to_v4i1:
 ; AVX512DQ:       # %bb.0:
 ; AVX512DQ-NEXT:    vcvttps2dq %xmm0, %xmm0
+; AVX512DQ-NEXT:    vpslld $31, %xmm0, %xmm0
 ; AVX512DQ-NEXT:    vpmovd2m %zmm0, %k0
 ; AVX512DQ-NEXT:    vpmovm2d %k0, %zmm0
 ; AVX512DQ-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512DQ-NEXT:    vzeroupper
 ; AVX512DQ-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512VLDQ-LABEL: strict_vector_fptosi_v4f32_to_v4i1:
 ; AVX512VLDQ:       # %bb.0:
 ; AVX512VLDQ-NEXT:    vcvttps2dq %xmm0, %xmm0
+; AVX512VLDQ-NEXT:    vpslld $31, %xmm0, %xmm0
 ; AVX512VLDQ-NEXT:    vpmovd2m %xmm0, %k0
 ; AVX512VLDQ-NEXT:    vpmovm2d %k0, %xmm0
 ; AVX512VLDQ-NEXT:    ret{{[l|q]}}
   %ret = call <4 x i1> @llvm.experimental.constrained.fptosi.v4i1.v4f32(<4 x float> %a,
                                               metadata !"fpexcept.strict") #0
   ret <4 x i1> %ret
 }
 

llvm/test/CodeGen/X86/vec-strict-fptoint-256.ll

%ret = call <4 x i32> @llvm.experimental.constrained.fptoui.v4i32.v4f64(<4 x double> %a,
                                               metadata !"fpexcept.strict") #0
   ret <4 x i32> %ret
 }
 
 define <4 x i16> @strict_vector_fptosi_v4f64_to_v4i16(<4 x double> %a) #0 {
 ; CHECK-LABEL: strict_vector_fptosi_v4f64_to_v4i16:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    vcvttpd2dq %ymm0, %xmm0
-; CHECK-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
+; CHECK-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,1,4,5,8,9,12,13,8,9,12,13,12,13,14,15]
 ; CHECK-NEXT:    vzeroupper
 ; CHECK-NEXT:    ret{{[l|q]}}
   %ret = call <4 x i16> @llvm.experimental.constrained.fptosi.v4i16.v4f64(<4 x double> %a,
                                               metadata !"fpexcept.strict") #0
   ret <4 x i16> %ret
 }
 
 define <4 x i16> @strict_vector_fptoui_v4f64_to_v4i16(<4 x double> %a) #0 {
 ; CHECK-LABEL: strict_vector_fptoui_v4f64_to_v4i16:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    vcvttpd2dq %ymm0, %xmm0
-; CHECK-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
+; CHECK-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,1,4,5,8,9,12,13,8,9,12,13,12,13,14,15]
 ; CHECK-NEXT:    vzeroupper
 ; CHECK-NEXT:    ret{{[l|q]}}
   %ret = call <4 x i16> @llvm.experimental.constrained.fptoui.v4i16.v4f64(<4 x double> %a,
                                               metadata !"fpexcept.strict") #0
   ret <4 x i16> %ret
 }
 
 define <4 x i8> @strict_vector_fptosi_v4f64_to_v4i8(<4 x double> %a) #0 {
 ; AVX-LABEL: strict_vector_fptosi_v4f64_to_v4i8:
 ; AVX:       # %bb.0:
 ; AVX-NEXT:    vcvttpd2dq %ymm0, %xmm0
-; AVX-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
-; AVX-NEXT:    vpacksswb %xmm0, %xmm0, %xmm0
+; AVX-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,8,12,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX-NEXT:    vzeroupper
 ; AVX-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512F-LABEL: strict_vector_fptosi_v4f64_to_v4i8:
 ; AVX512F:       # %bb.0:
 ; AVX512F-NEXT:    vcvttpd2dq %ymm0, %xmm0
-; AVX512F-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
-; AVX512F-NEXT:    vpacksswb %xmm0, %xmm0, %xmm0
+; AVX512F-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,8,12,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX512F-NEXT:    vzeroupper
 ; AVX512F-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512VL-LABEL: strict_vector_fptosi_v4f64_to_v4i8:
 ; AVX512VL:       # %bb.0:
 ; AVX512VL-NEXT:    vcvttpd2dq %ymm0, %xmm0
 ; AVX512VL-NEXT:    vpmovdb %xmm0, %xmm0
 ; AVX512VL-NEXT:    vzeroupper
 ; AVX512VL-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512DQ-LABEL: strict_vector_fptosi_v4f64_to_v4i8:
 ; AVX512DQ:       # %bb.0:
 ; AVX512DQ-NEXT:    vcvttpd2dq %ymm0, %xmm0
-; AVX512DQ-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
-; AVX512DQ-NEXT:    vpacksswb %xmm0, %xmm0, %xmm0
+; AVX512DQ-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,8,12,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX512DQ-NEXT:    vzeroupper
 ; AVX512DQ-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512DQVL-LABEL: strict_vector_fptosi_v4f64_to_v4i8:
 ; AVX512DQVL:       # %bb.0:
 ; AVX512DQVL-NEXT:    vcvttpd2dq %ymm0, %xmm0
 ; AVX512DQVL-NEXT:    vpmovdb %xmm0, %xmm0
 ; AVX512DQVL-NEXT:    vzeroupper
 ; AVX512DQVL-NEXT:    ret{{[l|q]}}
   %ret = call <4 x i8> @llvm.experimental.constrained.fptosi.v4i8.v4f64(<4 x double> %a,
                                               metadata !"fpexcept.strict") #0
   ret <4 x i8> %ret
 }
 
 define <4 x i8> @strict_vector_fptoui_v4f64_to_v4i8(<4 x double> %a) #0 {
 ; AVX-LABEL: strict_vector_fptoui_v4f64_to_v4i8:
 ; AVX:       # %bb.0:
 ; AVX-NEXT:    vcvttpd2dq %ymm0, %xmm0
-; AVX-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
-; AVX-NEXT:    vpackuswb %xmm0, %xmm0, %xmm0
+; AVX-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,8,12,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX-NEXT:    vzeroupper
 ; AVX-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512F-LABEL: strict_vector_fptoui_v4f64_to_v4i8:
 ; AVX512F:       # %bb.0:
 ; AVX512F-NEXT:    vcvttpd2dq %ymm0, %xmm0
-; AVX512F-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
-; AVX512F-NEXT:    vpackuswb %xmm0, %xmm0, %xmm0
+; AVX512F-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,8,12,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX512F-NEXT:    vzeroupper
 ; AVX512F-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512VL-LABEL: strict_vector_fptoui_v4f64_to_v4i8:
 ; AVX512VL:       # %bb.0:
 ; AVX512VL-NEXT:    vcvttpd2dq %ymm0, %xmm0
 ; AVX512VL-NEXT:    vpmovdb %xmm0, %xmm0
 ; AVX512VL-NEXT:    vzeroupper
 ; AVX512VL-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512DQ-LABEL: strict_vector_fptoui_v4f64_to_v4i8:
 ; AVX512DQ:       # %bb.0:
 ; AVX512DQ-NEXT:    vcvttpd2dq %ymm0, %xmm0
-; AVX512DQ-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
-; AVX512DQ-NEXT:    vpackuswb %xmm0, %xmm0, %xmm0
+; AVX512DQ-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,8,12,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX512DQ-NEXT:    vzeroupper
 ; AVX512DQ-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512DQVL-LABEL: strict_vector_fptoui_v4f64_to_v4i8:
 ; AVX512DQVL:       # %bb.0:
 ; AVX512DQVL-NEXT:    vcvttpd2dq %ymm0, %xmm0
 ; AVX512DQVL-NEXT:    vpmovdb %xmm0, %xmm0
 ; AVX512DQVL-NEXT:    vzeroupper
 ; AVX512DQVL-NEXT:    ret{{[l|q]}}
   %ret = call <4 x i8> @llvm.experimental.constrained.fptoui.v4i8.v4f64(<4 x double> %a,
                                               metadata !"fpexcept.strict") #0
   ret <4 x i8> %ret
 }
 
 define <4 x i1> @strict_vector_fptosi_v4f64_to_v4i1(<4 x double> %a) #0 {
 ; AVX-LABEL: strict_vector_fptosi_v4f64_to_v4i1:
 ; AVX:       # %bb.0:
 ; AVX-NEXT:    vcvttpd2dq %ymm0, %xmm0
 ; AVX-NEXT:    vzeroupper
 ; AVX-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512F-LABEL: strict_vector_fptosi_v4f64_to_v4i1:
 ; AVX512F:       # %bb.0:
 ; AVX512F-NEXT:    vcvttpd2dq %ymm0, %xmm0
+; AVX512F-NEXT:    vpslld $31, %xmm0, %xmm0
 ; AVX512F-NEXT:    vptestmd %zmm0, %zmm0, %k1
 ; AVX512F-NEXT:    vpternlogd $255, %zmm0, %zmm0, %zmm0 {%k1} {z}
 ; AVX512F-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512F-NEXT:    vzeroupper
 ; AVX512F-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512VL-LABEL: strict_vector_fptosi_v4f64_to_v4i1:
 ; AVX512VL:       # %bb.0:
 ; AVX512VL-NEXT:    vcvttpd2dq %ymm0, %xmm0
+; AVX512VL-NEXT:    vpslld $31, %xmm0, %xmm0
 ; AVX512VL-NEXT:    vptestmd %xmm0, %xmm0, %k1
 ; AVX512VL-NEXT:    vpcmpeqd %xmm0, %xmm0, %xmm0
 ; AVX512VL-NEXT:    vmovdqa32 %xmm0, %xmm0 {%k1} {z}
 ; AVX512VL-NEXT:    vzeroupper
 ; AVX512VL-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512DQ-LABEL: strict_vector_fptosi_v4f64_to_v4i1:
 ; AVX512DQ:       # %bb.0:
 ; AVX512DQ-NEXT:    vcvttpd2dq %ymm0, %xmm0
+; AVX512DQ-NEXT:    vpslld $31, %xmm0, %xmm0
 ; AVX512DQ-NEXT:    vpmovd2m %zmm0, %k0
 ; AVX512DQ-NEXT:    vpmovm2d %k0, %zmm0
 ; AVX512DQ-NEXT:    # kill: def $xmm0 killed $xmm0 killed $zmm0
 ; AVX512DQ-NEXT:    vzeroupper
 ; AVX512DQ-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512DQVL-LABEL: strict_vector_fptosi_v4f64_to_v4i1:
 ; AVX512DQVL:       # %bb.0:
 ; AVX512DQVL-NEXT:    vcvttpd2dq %ymm0, %xmm0
+; AVX512DQVL-NEXT:    vpslld $31, %xmm0, %xmm0
 ; AVX512DQVL-NEXT:    vpmovd2m %xmm0, %k0
 ; AVX512DQVL-NEXT:    vpmovm2d %k0, %xmm0
 ; AVX512DQVL-NEXT:    vzeroupper
 ; AVX512DQVL-NEXT:    ret{{[l|q]}}
   %ret = call <4 x i1> @llvm.experimental.constrained.fptosi.v4i1.v4f64(<4 x double> %a,
                                               metadata !"fpexcept.strict") #0
   ret <4 x i1> %ret
 }
; AVX512DQVL-NEXT:    ret{{[l|q]}}
   ret <8 x i32> %ret
 }
 
 define <8 x i16> @strict_vector_fptosi_v8f32_to_v8i16(<8 x float> %a) #0 {
 ; AVX-LABEL: strict_vector_fptosi_v8f32_to_v8i16:
 ; AVX:       # %bb.0:
 ; AVX-NEXT:    vcvttps2dq %ymm0, %ymm0
 ; AVX-NEXT:    vextractf128 $1, %ymm0, %xmm1
-; AVX-NEXT:    vpackssdw %xmm1, %xmm0, %xmm0
+; AVX-NEXT:    vmovdqa {{.*#+}} xmm2 = <0,1,4,5,8,9,12,13,u,u,u,u,u,u,u,u>
+; AVX-NEXT:    vpshufb %xmm2, %xmm1, %xmm1
+; AVX-NEXT:    vpshufb %xmm2, %xmm0, %xmm0
+; AVX-NEXT:    vpunpcklqdq {{.*#+}} xmm0 = xmm0[0],xmm1[0]
 ; AVX-NEXT:    vzeroupper
 ; AVX-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512F-LABEL: strict_vector_fptosi_v8f32_to_v8i16:
 ; AVX512F:       # %bb.0:
 ; AVX512F-NEXT:    vcvttps2dq %ymm0, %ymm0
 ; AVX512F-NEXT:    vpmovdw %zmm0, %ymm0
 ; AVX512F-NEXT:    # kill: def $xmm0 killed $xmm0 killed $ymm0
; AVX512DQVL-NEXT:    ret{{[l|q]}}
   ret <8 x i16> %ret
 }
 
 define <8 x i16> @strict_vector_fptoui_v8f32_to_v8i16(<8 x float> %a) #0 {
 ; AVX-LABEL: strict_vector_fptoui_v8f32_to_v8i16:
 ; AVX:       # %bb.0:
 ; AVX-NEXT:    vcvttps2dq %ymm0, %ymm0
 ; AVX-NEXT:    vextractf128 $1, %ymm0, %xmm1
-; AVX-NEXT:    vpackusdw %xmm1, %xmm0, %xmm0
+; AVX-NEXT:    vmovdqa {{.*#+}} xmm2 = <0,1,4,5,8,9,12,13,u,u,u,u,u,u,u,u>
+; AVX-NEXT:    vpshufb %xmm2, %xmm1, %xmm1
+; AVX-NEXT:    vpshufb %xmm2, %xmm0, %xmm0
+; AVX-NEXT:    vpunpcklqdq {{.*#+}} xmm0 = xmm0[0],xmm1[0]
 ; AVX-NEXT:    vzeroupper
 ; AVX-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512F-LABEL: strict_vector_fptoui_v8f32_to_v8i16:
 ; AVX512F:       # %bb.0:
 ; AVX512F-NEXT:    vcvttps2dq %ymm0, %ymm0
 ; AVX512F-NEXT:    vpmovdw %zmm0, %ymm0
 ; AVX512F-NEXT:    # kill: def $xmm0 killed $xmm0 killed $ymm0
; AVX512DQVL-NEXT:    ret{{[l|q]}}
   ret <8 x i16> %ret
 }
 
 define <8 x i8> @strict_vector_fptosi_v8f32_to_v8i8(<8 x float> %a) #0 {
 ; AVX-LABEL: strict_vector_fptosi_v8f32_to_v8i8:
 ; AVX:       # %bb.0:
 ; AVX-NEXT:    vcvttps2dq %ymm0, %ymm0
 ; AVX-NEXT:    vextractf128 $1, %ymm0, %xmm1
-; AVX-NEXT:    vpackssdw %xmm1, %xmm0, %xmm0
-; AVX-NEXT:    vpacksswb %xmm0, %xmm0, %xmm0
+; AVX-NEXT:    vmovdqa {{.*#+}} xmm2 = <0,4,8,12,u,u,u,u,u,u,u,u,u,u,u,u>
+; AVX-NEXT:    vpshufb %xmm2, %xmm1, %xmm1
+; AVX-NEXT:    vpshufb %xmm2, %xmm0, %xmm0
+; AVX-NEXT:    vpunpckldq {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
 ; AVX-NEXT:    vzeroupper
 ; AVX-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512F-LABEL: strict_vector_fptosi_v8f32_to_v8i8:
 ; AVX512F:       # %bb.0:
 ; AVX512F-NEXT:    vcvttps2dq %ymm0, %ymm0
 ; AVX512F-NEXT:    vpmovdb %zmm0, %xmm0
 ; AVX512F-NEXT:    vzeroupper
; AVX512DQVL-NEXT:    ret{{[l|q]}}
   ret <8 x i8> %ret
 }
 
 define <8 x i8> @strict_vector_fptoui_v8f32_to_v8i8(<8 x float> %a) #0 {
 ; AVX-LABEL: strict_vector_fptoui_v8f32_to_v8i8:
 ; AVX:       # %bb.0:
 ; AVX-NEXT:    vcvttps2dq %ymm0, %ymm0
 ; AVX-NEXT:    vextractf128 $1, %ymm0, %xmm1
-; AVX-NEXT:    vpackssdw %xmm1, %xmm0, %xmm0
-; AVX-NEXT:    vpackuswb %xmm0, %xmm0, %xmm0
+; AVX-NEXT:    vmovdqa {{.*#+}} xmm2 = <0,4,8,12,u,u,u,u,u,u,u,u,u,u,u,u>
+; AVX-NEXT:    vpshufb %xmm2, %xmm1, %xmm1
+; AVX-NEXT:    vpshufb %xmm2, %xmm0, %xmm0
+; AVX-NEXT:    vpunpckldq {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
 ; AVX-NEXT:    vzeroupper
 ; AVX-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512F-LABEL: strict_vector_fptoui_v8f32_to_v8i8:
 ; AVX512F:       # %bb.0:
 ; AVX512F-NEXT:    vcvttps2dq %ymm0, %ymm0
 ; AVX512F-NEXT:    vpmovdb %zmm0, %xmm0
 ; AVX512F-NEXT:    vzeroupper
; AVX512DQVL-NEXT:    ret{{[l|q]}}
   ret <8 x i8> %ret
 }
 
 define <8 x i1> @strict_vector_fptosi_v8f32_to_v8i1(<8 x float> %a) #0 {
 ; AVX-LABEL: strict_vector_fptosi_v8f32_to_v8i1:
 ; AVX:       # %bb.0:
 ; AVX-NEXT:    vcvttps2dq %ymm0, %ymm0
 ; AVX-NEXT:    vextractf128 $1, %ymm0, %xmm1
-; AVX-NEXT:    vpackssdw %xmm1, %xmm0, %xmm0
+; AVX-NEXT:    vmovdqa {{.*#+}} xmm2 = <0,1,4,5,8,9,12,13,u,u,u,u,u,u,u,u>
+; AVX-NEXT:    vpshufb %xmm2, %xmm1, %xmm1
+; AVX-NEXT:    vpshufb %xmm2, %xmm0, %xmm0
+; AVX-NEXT:    vpunpcklqdq {{.*#+}} xmm0 = xmm0[0],xmm1[0]
 ; AVX-NEXT:    vzeroupper
 ; AVX-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512F-LABEL: strict_vector_fptosi_v8f32_to_v8i1:
 ; AVX512F:       # %bb.0:
 ; AVX512F-NEXT:    vcvttps2dq %ymm0, %ymm0
+; AVX512F-NEXT:    vpslld $31, %ymm0, %ymm0
 ; AVX512F-NEXT:    vptestmd %zmm0, %zmm0, %k1
 ; AVX512F-NEXT:    vpternlogd $255, %zmm0, %zmm0, %zmm0 {%k1} {z}
 ; AVX512F-NEXT:    vpmovdw %zmm0, %ymm0
 ; AVX512F-NEXT:    # kill: def $xmm0 killed $xmm0 killed $ymm0
 ; AVX512F-NEXT:    vzeroupper
 ; AVX512F-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512VL-LABEL: strict_vector_fptosi_v8f32_to_v8i1:
 ; AVX512VL:       # %bb.0:
 ; AVX512VL-NEXT:    vcvttps2dq %ymm0, %ymm0
+; AVX512VL-NEXT:    vpslld $31, %ymm0, %ymm0
 ; AVX512VL-NEXT:    vptestmd %ymm0, %ymm0, %k1
 ; AVX512VL-NEXT:    vpcmpeqd %ymm0, %ymm0, %ymm0
 ; AVX512VL-NEXT:    vmovdqa32 %ymm0, %ymm0 {%k1} {z}
 ; AVX512VL-NEXT:    vpmovdw %ymm0, %xmm0
 ; AVX512VL-NEXT:    vzeroupper
 ; AVX512VL-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512DQ-LABEL: strict_vector_fptosi_v8f32_to_v8i1:
 ; AVX512DQ:       # %bb.0:
 ; AVX512DQ-NEXT:    vcvttps2dq %ymm0, %ymm0
+; AVX512DQ-NEXT:    vpslld $31, %ymm0, %ymm0
 ; AVX512DQ-NEXT:    vpmovd2m %zmm0, %k0
 ; AVX512DQ-NEXT:    vpmovm2d %k0, %zmm0
 ; AVX512DQ-NEXT:    vpmovdw %zmm0, %ymm0
 ; AVX512DQ-NEXT:    # kill: def $xmm0 killed $xmm0 killed $ymm0
 ; AVX512DQ-NEXT:    vzeroupper
 ; AVX512DQ-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512DQVL-LABEL: strict_vector_fptosi_v8f32_to_v8i1:
 ; AVX512DQVL:       # %bb.0:
 ; AVX512DQVL-NEXT:    vcvttps2dq %ymm0, %ymm0
+; AVX512DQVL-NEXT:    vpslld $31, %ymm0, %ymm0
 ; AVX512DQVL-NEXT:    vpmovd2m %ymm0, %k0
 ; AVX512DQVL-NEXT:    vpmovm2d %k0, %ymm0
 ; AVX512DQVL-NEXT:    vpmovdw %ymm0, %xmm0
 ; AVX512DQVL-NEXT:    vzeroupper
 ; AVX512DQVL-NEXT:    ret{{[l|q]}}
   %ret = call <8 x i1> @llvm.experimental.constrained.fptosi.v8i1.v8f32(<8 x float> %a,
                                               metadata !"fpexcept.strict") #0
   ret <8 x i1> %ret
 }
 
 define <8 x i1> @strict_vector_fptoui_v8f32_to_v8i1(<8 x float> %a) #0 {
 ; AVX-LABEL: strict_vector_fptoui_v8f32_to_v8i1:
 ; AVX:       # %bb.0:
 ; AVX-NEXT:    vcvttps2dq %ymm0, %ymm0
 ; AVX-NEXT:    vextractf128 $1, %ymm0, %xmm1
-; AVX-NEXT:    vpackusdw %xmm1, %xmm0, %xmm0
+; AVX-NEXT:    vmovdqa {{.*#+}} xmm2 = <0,1,4,5,8,9,12,13,u,u,u,u,u,u,u,u>
+; AVX-NEXT:    vpshufb %xmm2, %xmm1, %xmm1
+; AVX-NEXT:    vpshufb %xmm2, %xmm0, %xmm0
+; AVX-NEXT:    vpunpcklqdq {{.*#+}} xmm0 = xmm0[0],xmm1[0]
 ; AVX-NEXT:    vzeroupper
 ; AVX-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512F-LABEL: strict_vector_fptoui_v8f32_to_v8i1:
 ; AVX512F:       # %bb.0:
 ; AVX512F-NEXT:    vcvttps2dq %ymm0, %ymm0
 ; AVX512F-NEXT:    vpslld $31, %ymm0, %ymm0
 ; AVX512F-NEXT:    vptestmd %zmm0, %zmm0, %k1

llvm/test/CodeGen/X86/vec-strict-fptoint-512.ll

%ret = call <8 x i8> @llvm.experimental.constrained.fptoui.v8i8.v8f64(<8 x double> %a,
                                               metadata !"fpexcept.strict") #0
   ret <8 x i8> %ret
 }
 
 define <8 x i1> @strict_vector_fptosi_v8f64_to_v8i1(<8 x double> %a) #0 {
 ; AVX512VL-LABEL: strict_vector_fptosi_v8f64_to_v8i1:
 ; AVX512VL:       # %bb.0:
 ; AVX512VL-NEXT:    vcvttpd2dq %zmm0, %ymm0
+; AVX512VL-NEXT:    vpslld $31, %ymm0, %ymm0
 ; AVX512VL-NEXT:    vptestmd %ymm0, %ymm0, %k1
 ; AVX512VL-NEXT:    vpcmpeqd %ymm0, %ymm0, %ymm0
 ; AVX512VL-NEXT:    vmovdqa32 %ymm0, %ymm0 {%k1} {z}
 ; AVX512VL-NEXT:    vpmovdw %ymm0, %xmm0
 ; AVX512VL-NEXT:    vzeroupper
 ; AVX512VL-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512DQ-LABEL: strict_vector_fptosi_v8f64_to_v8i1:
 ; AVX512DQ:       # %bb.0:
 ; AVX512DQ-NEXT:    vcvttpd2dq %zmm0, %ymm0
+; AVX512DQ-NEXT:    vpslld $31, %ymm0, %ymm0
 ; AVX512DQ-NEXT:    vpmovd2m %zmm0, %k0
 ; AVX512DQ-NEXT:    vpmovm2d %k0, %zmm0
 ; AVX512DQ-NEXT:    vpmovdw %zmm0, %ymm0
 ; AVX512DQ-NEXT:    # kill: def $xmm0 killed $xmm0 killed $ymm0
 ; AVX512DQ-NEXT:    vzeroupper
 ; AVX512DQ-NEXT:    ret{{[l|q]}}
   %ret = call <8 x i1> @llvm.experimental.constrained.fptosi.v8i1.v8f64(<8 x double> %a,
                                               metadata !"fpexcept.strict") #0
%ret = call <16 x i8> @llvm.experimental.constrained.fptoui.v16i8.v16f32(<16 x float> %a,
                                               metadata !"fpexcept.strict") #0
   ret <16 x i8> %ret
 }
 
 define <16 x i1> @strict_vector_fptosi_v16f32_to_v16i1(<16 x float> %a) #0 {
 ; AVX512VL-LABEL: strict_vector_fptosi_v16f32_to_v16i1:
 ; AVX512VL:       # %bb.0:
 ; AVX512VL-NEXT:    vcvttps2dq %zmm0, %zmm0
+; AVX512VL-NEXT:    vpslld $31, %zmm0, %zmm0
 ; AVX512VL-NEXT:    vptestmd %zmm0, %zmm0, %k1
 ; AVX512VL-NEXT:    vpternlogd $255, %zmm0, %zmm0, %zmm0 {%k1} {z}
 ; AVX512VL-NEXT:    vpmovdb %zmm0, %xmm0
 ; AVX512VL-NEXT:    vzeroupper
 ; AVX512VL-NEXT:    ret{{[l|q]}}
 ;
 ; AVX512DQ-LABEL: strict_vector_fptosi_v16f32_to_v16i1:
 ; AVX512DQ:       # %bb.0:
 ; AVX512DQ-NEXT:    vcvttps2dq %zmm0, %zmm0
+; AVX512DQ-NEXT:    vpslld $31, %zmm0, %zmm0
 ; AVX512DQ-NEXT:    vpmovd2m %zmm0, %k0
 ; AVX512DQ-NEXT:    vpmovm2d %k0, %zmm0
 ; AVX512DQ-NEXT:    vpmovdb %zmm0, %xmm0
 ; AVX512DQ-NEXT:    vzeroupper
 ; AVX512DQ-NEXT:    ret{{[l|q]}}
   %ret = call <16 x i1> @llvm.experimental.constrained.fptosi.v16i1.v16f32(<16 x float> %a,
                                               metadata !"fpexcept.strict") #0
   ret <16 x i1> %ret

llvm/test/CodeGen/X86/vec_cast2.ll

; CHECK-NEXT:    retl
   ret <4 x float> %res
 }
 
 define <8 x i8> @cvt_v8f32_v8i8(<8 x float> %src) {
 ; CHECK-LABEL: cvt_v8f32_v8i8:
 ; CHECK:       ## %bb.0:
 ; CHECK-NEXT:    vcvttps2dq %ymm0, %ymm0
 ; CHECK-NEXT:    vextractf128 $1, %ymm0, %xmm1
-; CHECK-NEXT:    vpackssdw %xmm1, %xmm0, %xmm0
-; CHECK-NEXT:    vpacksswb %xmm0, %xmm0, %xmm0
+; CHECK-NEXT:    vmovdqa {{.*#+}} xmm2 = <0,4,8,12,u,u,u,u,u,u,u,u,u,u,u,u>
+; CHECK-NEXT:    vpshufb %xmm2, %xmm1, %xmm1
+; CHECK-NEXT:    vpshufb %xmm2, %xmm0, %xmm0
+; CHECK-NEXT:    vpunpckldq {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
 ; CHECK-NEXT:    vzeroupper
 ; CHECK-NEXT:    retl
   %res = fptosi <8 x float> %src to <8 x i8>
   ret <8 x i8> %res
 }
 
 define <8 x i16> @cvt_v8f32_v8i16(<8 x float> %src) {
 ; CHECK-LABEL: cvt_v8f32_v8i16:
 ; CHECK:       ## %bb.0:
 ; CHECK-NEXT:    vcvttps2dq %ymm0, %ymm0
 ; CHECK-NEXT:    vextractf128 $1, %ymm0, %xmm1
-; CHECK-NEXT:    vpackssdw %xmm1, %xmm0, %xmm0
+; CHECK-NEXT:    vmovdqa {{.*#+}} xmm2 = <0,1,4,5,8,9,12,13,u,u,u,u,u,u,u,u>
+; CHECK-NEXT:    vpshufb %xmm2, %xmm1, %xmm1
+; CHECK-NEXT:    vpshufb %xmm2, %xmm0, %xmm0
+; CHECK-NEXT:    vpunpcklqdq {{.*#+}} xmm0 = xmm0[0],xmm1[0]
 ; CHECK-NEXT:    vzeroupper
 ; CHECK-NEXT:    retl
   %res = fptosi <8 x float> %src to <8 x i16>
   ret <8 x i16> %res
 }
 
 define <4 x i8> @cvt_v4f32_v4i8(<4 x float> %src) {
 ; CHECK-LABEL: cvt_v4f32_v4i8:
 ; CHECK:       ## %bb.0:
 ; CHECK-NEXT:    vcvttps2dq %xmm0, %xmm0
-; CHECK-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
-; CHECK-NEXT:    vpacksswb %xmm0, %xmm0, %xmm0
+; CHECK-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,8,12,u,u,u,u,u,u,u,u,u,u,u,u]
 ; CHECK-NEXT:    retl
   %res = fptosi <4 x float> %src to <4 x i8>
   ret <4 x i8> %res
 }
 
 define <4 x i16> @cvt_v4f32_v4i16(<4 x float> %src) {
 ; CHECK-LABEL: cvt_v4f32_v4i16:
 ; CHECK:       ## %bb.0:
 ; CHECK-NEXT:    vcvttps2dq %xmm0, %xmm0
-; CHECK-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
+; CHECK-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,1,4,5,8,9,12,13,8,9,12,13,12,13,14,15]
 ; CHECK-NEXT:    retl
   %res = fptosi <4 x float> %src to <4 x i16>
   ret <4 x i16> %res
 }
 
 define <8 x i8> @cvt_v8f32_v8u8(<8 x float> %src) {
 ; CHECK-LABEL: cvt_v8f32_v8u8:
 ; CHECK:       ## %bb.0:
 ; CHECK-NEXT:    vcvttps2dq %ymm0, %ymm0
 ; CHECK-NEXT:    vextractf128 $1, %ymm0, %xmm1
-; CHECK-NEXT:    vpackssdw %xmm1, %xmm0, %xmm0
-; CHECK-NEXT:    vpackuswb %xmm0, %xmm0, %xmm0
+; CHECK-NEXT:    vmovdqa {{.*#+}} xmm2 = <0,4,8,12,u,u,u,u,u,u,u,u,u,u,u,u>
+; CHECK-NEXT:    vpshufb %xmm2, %xmm1, %xmm1
+; CHECK-NEXT:    vpshufb %xmm2, %xmm0, %xmm0
+; CHECK-NEXT:    vpunpckldq {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
 ; CHECK-NEXT:    vzeroupper
 ; CHECK-NEXT:    retl
   %res = fptoui <8 x float> %src to <8 x i8>
   ret <8 x i8> %res
 }
 
 define <8 x i16> @cvt_v8f32_v8u16(<8 x float> %src) {
 ; CHECK-LABEL: cvt_v8f32_v8u16:
 ; CHECK:       ## %bb.0:
 ; CHECK-NEXT:    vcvttps2dq %ymm0, %ymm0
 ; CHECK-NEXT:    vextractf128 $1, %ymm0, %xmm1
-; CHECK-NEXT:    vpackusdw %xmm1, %xmm0, %xmm0
+; CHECK-NEXT:    vmovdqa {{.*#+}} xmm2 = <0,1,4,5,8,9,12,13,u,u,u,u,u,u,u,u>
+; CHECK-NEXT:    vpshufb %xmm2, %xmm1, %xmm1
+; CHECK-NEXT:    vpshufb %xmm2, %xmm0, %xmm0
+; CHECK-NEXT:    vpunpcklqdq {{.*#+}} xmm0 = xmm0[0],xmm1[0]
 ; CHECK-NEXT:    vzeroupper
 ; CHECK-NEXT:    retl
   %res = fptoui <8 x float> %src to <8 x i16>
   ret <8 x i16> %res
 }
 
 define <4 x i8> @cvt_v4f32_v4u8(<4 x float> %src) {
 ; CHECK-LABEL: cvt_v4f32_v4u8:
 ; CHECK:       ## %bb.0:
 ; CHECK-NEXT:    vcvttps2dq %xmm0, %xmm0
-; CHECK-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
-; CHECK-NEXT:    vpackuswb %xmm0, %xmm0, %xmm0
+; CHECK-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,8,12,u,u,u,u,u,u,u,u,u,u,u,u]
 ; CHECK-NEXT:    retl
   %res = fptoui <4 x float> %src to <4 x i8>
   ret <4 x i8> %res
 }
 
 define <4 x i16> @cvt_v4f32_v4u16(<4 x float> %src) {
 ; CHECK-LABEL: cvt_v4f32_v4u16:
 ; CHECK:       ## %bb.0:
 ; CHECK-NEXT:    vcvttps2dq %xmm0, %xmm0
-; CHECK-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
+; CHECK-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,1,4,5,8,9,12,13,8,9,12,13,12,13,14,15]
 ; CHECK-NEXT:    retl
   %res = fptoui <4 x float> %src to <4 x i16>
   ret <4 x i16> %res
 }
 

llvm/test/CodeGen/X86/vec_cast3.ll

; CHECK-NEXT:    retl
   %res = uitofp <2 x i32> %src to <2 x float>
   ret <2 x float> %res
 }
 
 define <2 x i8> @cvt_v2f32_v2i8(<2 x float> %src) {
 ; CHECK-LABEL: cvt_v2f32_v2i8:
 ; CHECK:       ## %bb.0:
 ; CHECK-NEXT:    vcvttps2dq %xmm0, %xmm0
-; CHECK-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
-; CHECK-NEXT:    vpacksswb %xmm0, %xmm0, %xmm0
+; CHECK-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,u,u,u,u,u,u,u,u,u,u,u,u,u,u]
 ; CHECK-NEXT:    retl
   %res = fptosi <2 x float> %src to <2 x i8>
   ret <2 x i8> %res
 }
 
 define <2 x i16> @cvt_v2f32_v2i16(<2 x float> %src) {
 ; CHECK-LABEL: cvt_v2f32_v2i16:
 ; CHECK:       ## %bb.0:
 ; CHECK-NEXT:    vcvttps2dq %xmm0, %xmm0
-; CHECK-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
+; CHECK-NEXT:    vpshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; CHECK-NEXT:    retl
   %res = fptosi <2 x float> %src to <2 x i16>
   ret <2 x i16> %res
 }
 
 define <2 x i32> @cvt_v2f32_v2i32(<2 x float> %src) {
 ; CHECK-LABEL: cvt_v2f32_v2i32:
 ; CHECK:       ## %bb.0:
 ; CHECK-NEXT:    vcvttps2dq %xmm0, %xmm0
 ; CHECK-NEXT:    retl
   %res = fptosi <2 x float> %src to <2 x i32>
   ret <2 x i32> %res
 }
 
 define <2 x i8> @cvt_v2f32_v2u8(<2 x float> %src) {
 ; CHECK-LABEL: cvt_v2f32_v2u8:
 ; CHECK:       ## %bb.0:
 ; CHECK-NEXT:    vcvttps2dq %xmm0, %xmm0
-; CHECK-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
-; CHECK-NEXT:    vpackuswb %xmm0, %xmm0, %xmm0
+; CHECK-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,u,u,u,u,u,u,u,u,u,u,u,u,u,u]
 ; CHECK-NEXT:    retl
   %res = fptoui <2 x float> %src to <2 x i8>
   ret <2 x i8> %res
 }
 
 define <2 x i16> @cvt_v2f32_v2u16(<2 x float> %src) {
 ; CHECK-LABEL: cvt_v2f32_v2u16:
 ; CHECK:       ## %bb.0:
 ; CHECK-NEXT:    vcvttps2dq %xmm0, %xmm0
-; CHECK-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
+; CHECK-NEXT:    vpshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; CHECK-NEXT:    retl
   %res = fptoui <2 x float> %src to <2 x i16>
   ret <2 x i16> %res
 }
 
 define <2 x i32> @cvt_v2f32_v2u32(<2 x float> %src) {
 ; CHECK-LABEL: cvt_v2f32_v2u32:
 ; CHECK:       ## %bb.0:

llvm/test/CodeGen/X86/vec_fp_to_int.ll

; AVX-NEXT:    retq
   %ext = shufflevector <2 x i32> %cvt, <2 x i32> zeroinitializer, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
   ret <4 x i32> %ext
 }
 
 define <2 x i8> @fptosi_2f32_to_2i8(<2 x float> %a) {
 ; SSE-LABEL: fptosi_2f32_to_2i8:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    cvttps2dq %xmm0, %xmm0
-; SSE-NEXT:    packssdw %xmm0, %xmm0
-; SSE-NEXT:    packsswb %xmm0, %xmm0
+; SSE-NEXT:    pand {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0
+; SSE-NEXT:    packuswb %xmm0, %xmm0
+; SSE-NEXT:    packuswb %xmm0, %xmm0
 ; SSE-NEXT:    retq
 ;
 ; VEX-LABEL: fptosi_2f32_to_2i8:
 ; VEX:       # %bb.0:
 ; VEX-NEXT:    vcvttps2dq %xmm0, %xmm0
-; VEX-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
-; VEX-NEXT:    vpacksswb %xmm0, %xmm0, %xmm0
+; VEX-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,u,u,u,u,u,u,u,u,u,u,u,u,u,u]
 ; VEX-NEXT:    retq
 ;
 ; AVX512F-LABEL: fptosi_2f32_to_2i8:
 ; AVX512F:       # %bb.0:
 ; AVX512F-NEXT:    vcvttps2dq %xmm0, %xmm0
-; AVX512F-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
-; AVX512F-NEXT:    vpacksswb %xmm0, %xmm0, %xmm0
+; AVX512F-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,u,u,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX512F-NEXT:    retq
 ;
 ; AVX512VL-LABEL: fptosi_2f32_to_2i8:
 ; AVX512VL:       # %bb.0:
 ; AVX512VL-NEXT:    vcvttps2dq %xmm0, %xmm0
 ; AVX512VL-NEXT:    vpmovdb %xmm0, %xmm0
 ; AVX512VL-NEXT:    retq
 ;
 ; AVX512DQ-LABEL: fptosi_2f32_to_2i8:
 ; AVX512DQ:       # %bb.0:
 ; AVX512DQ-NEXT:    vcvttps2dq %xmm0, %xmm0
-; AVX512DQ-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
-; AVX512DQ-NEXT:    vpacksswb %xmm0, %xmm0, %xmm0
+; AVX512DQ-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,u,u,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX512DQ-NEXT:    retq
 ;
 ; AVX512VLDQ-LABEL: fptosi_2f32_to_2i8:
 ; AVX512VLDQ:       # %bb.0:
 ; AVX512VLDQ-NEXT:    vcvttps2dq %xmm0, %xmm0
 ; AVX512VLDQ-NEXT:    vpmovdb %xmm0, %xmm0
 ; AVX512VLDQ-NEXT:    retq
   %cvt = fptosi <2 x float> %a to <2 x i8>
   ret <2 x i8> %cvt
 }
 
 define <2 x i16> @fptosi_2f32_to_2i16(<2 x float> %a) {
 ; SSE-LABEL: fptosi_2f32_to_2i16:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    cvttps2dq %xmm0, %xmm0
-; SSE-NEXT:    packssdw %xmm0, %xmm0
+; SSE-NEXT:    pshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; SSE-NEXT:    retq
 ;
 ; AVX-LABEL: fptosi_2f32_to_2i16:
 ; AVX:       # %bb.0:
 ; AVX-NEXT:    vcvttps2dq %xmm0, %xmm0
-; AVX-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
+; AVX-NEXT:    vpshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; AVX-NEXT:    retq
   %cvt = fptosi <2 x float> %a to <2 x i16>
   ret <2 x i16> %cvt
 }
 
 define <2 x i8> @fptoui_2f32_to_2i8(<2 x float> %a) {
 ; SSE-LABEL: fptoui_2f32_to_2i8:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    cvttps2dq %xmm0, %xmm0
+; SSE-NEXT:    pand {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0
 ; SSE-NEXT:    packuswb %xmm0, %xmm0
 ; SSE-NEXT:    packuswb %xmm0, %xmm0
 ; SSE-NEXT:    retq
 ;
 ; VEX-LABEL: fptoui_2f32_to_2i8:
 ; VEX:       # %bb.0:
 ; VEX-NEXT:    vcvttps2dq %xmm0, %xmm0
-; VEX-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
-; VEX-NEXT:    vpackuswb %xmm0, %xmm0, %xmm0
+; VEX-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,u,u,u,u,u,u,u,u,u,u,u,u,u,u]
 ; VEX-NEXT:    retq
 ;
 ; AVX512F-LABEL: fptoui_2f32_to_2i8:
 ; AVX512F:       # %bb.0:
 ; AVX512F-NEXT:    vcvttps2dq %xmm0, %xmm0
-; AVX512F-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
-; AVX512F-NEXT:    vpackuswb %xmm0, %xmm0, %xmm0
+; AVX512F-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,u,u,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX512F-NEXT:    retq
 ;
 ; AVX512VL-LABEL: fptoui_2f32_to_2i8:
 ; AVX512VL:       # %bb.0:
 ; AVX512VL-NEXT:    vcvttps2dq %xmm0, %xmm0
 ; AVX512VL-NEXT:    vpmovdb %xmm0, %xmm0
 ; AVX512VL-NEXT:    retq
 ;
 ; AVX512DQ-LABEL: fptoui_2f32_to_2i8:
 ; AVX512DQ:       # %bb.0:
 ; AVX512DQ-NEXT:    vcvttps2dq %xmm0, %xmm0
-; AVX512DQ-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
-; AVX512DQ-NEXT:    vpackuswb %xmm0, %xmm0, %xmm0
+; AVX512DQ-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,u,u,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX512DQ-NEXT:    retq
 ;
 ; AVX512VLDQ-LABEL: fptoui_2f32_to_2i8:
 ; AVX512VLDQ:       # %bb.0:
 ; AVX512VLDQ-NEXT:    vcvttps2dq %xmm0, %xmm0
 ; AVX512VLDQ-NEXT:    vpmovdb %xmm0, %xmm0
 ; AVX512VLDQ-NEXT:    retq
   %cvt = fptoui <2 x float> %a to <2 x i8>
   ret <2 x i8> %cvt
 }
 
 define <2 x i16> @fptoui_2f32_to_2i16(<2 x float> %a) {
 ; SSE-LABEL: fptoui_2f32_to_2i16:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    cvttps2dq %xmm0, %xmm0
 ; SSE-NEXT:    pshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; SSE-NEXT:    retq
 ;
 ; AVX-LABEL: fptoui_2f32_to_2i16:
 ; AVX:       # %bb.0:
 ; AVX-NEXT:    vcvttps2dq %xmm0, %xmm0
-; AVX-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
+; AVX-NEXT:    vpshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; AVX-NEXT:    retq
   %cvt = fptoui <2 x float> %a to <2 x i16>
   ret <2 x i16> %cvt
 }
 
 define <2 x i8> @fptosi_2f64_to_2i8(<2 x double> %a) {
 ; SSE-LABEL: fptosi_2f64_to_2i8:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    cvttpd2dq %xmm0, %xmm0
-; SSE-NEXT:    packssdw %xmm0, %xmm0
-; SSE-NEXT:    packsswb %xmm0, %xmm0
+; SSE-NEXT:    andpd {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0
+; SSE-NEXT:    packuswb %xmm0, %xmm0
+; SSE-NEXT:    packuswb %xmm0, %xmm0
 ; SSE-NEXT:    retq
 ;
 ; VEX-LABEL: fptosi_2f64_to_2i8:
 ; VEX:       # %bb.0:
 ; VEX-NEXT:    vcvttpd2dq %xmm0, %xmm0
-; VEX-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
-; VEX-NEXT:    vpacksswb %xmm0, %xmm0, %xmm0
+; VEX-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,u,u,u,u,u,u,u,u,u,u,u,u,u,u]
 ; VEX-NEXT:    retq
 ;
 ; AVX512F-LABEL: fptosi_2f64_to_2i8:
 ; AVX512F:       # %bb.0:
 ; AVX512F-NEXT:    vcvttpd2dq %xmm0, %xmm0
-; AVX512F-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
-; AVX512F-NEXT:    vpacksswb %xmm0, %xmm0, %xmm0
+; AVX512F-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,u,u,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX512F-NEXT:    retq
 ;
 ; AVX512VL-LABEL: fptosi_2f64_to_2i8:
 ; AVX512VL:       # %bb.0:
 ; AVX512VL-NEXT:    vcvttpd2dq %xmm0, %xmm0
 ; AVX512VL-NEXT:    vpmovdb %xmm0, %xmm0
 ; AVX512VL-NEXT:    retq
 ;
 ; AVX512DQ-LABEL: fptosi_2f64_to_2i8:
 ; AVX512DQ:       # %bb.0:
 ; AVX512DQ-NEXT:    vcvttpd2dq %xmm0, %xmm0
-; AVX512DQ-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
-; AVX512DQ-NEXT:    vpacksswb %xmm0, %xmm0, %xmm0
+; AVX512DQ-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,u,u,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX512DQ-NEXT:    retq
 ;
 ; AVX512VLDQ-LABEL: fptosi_2f64_to_2i8:
 ; AVX512VLDQ:       # %bb.0:
 ; AVX512VLDQ-NEXT:    vcvttpd2dq %xmm0, %xmm0
 ; AVX512VLDQ-NEXT:    vpmovdb %xmm0, %xmm0
 ; AVX512VLDQ-NEXT:    retq
   %cvt = fptosi <2 x double> %a to <2 x i8>
   ret <2 x i8> %cvt
 }
 
 define <2 x i16> @fptosi_2f64_to_2i16(<2 x double> %a) {
 ; SSE-LABEL: fptosi_2f64_to_2i16:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    cvttpd2dq %xmm0, %xmm0
-; SSE-NEXT:    packssdw %xmm0, %xmm0
+; SSE-NEXT:    pshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; SSE-NEXT:    retq
 ;
 ; AVX-LABEL: fptosi_2f64_to_2i16:
 ; AVX:       # %bb.0:
 ; AVX-NEXT:    vcvttpd2dq %xmm0, %xmm0
-; AVX-NEXT:    vpackssdw %xmm0, %xmm0, %xmm0
+; AVX-NEXT:    vpshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; AVX-NEXT:    retq
   %cvt = fptosi <2 x double> %a to <2 x i16>
   ret <2 x i16> %cvt
 }
 
 define <2 x i8> @fptoui_2f64_to_2i8(<2 x double> %a) {
 ; SSE-LABEL: fptoui_2f64_to_2i8:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    cvttpd2dq %xmm0, %xmm0
+; SSE-NEXT:    andpd {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0
 ; SSE-NEXT:    packuswb %xmm0, %xmm0
 ; SSE-NEXT:    packuswb %xmm0, %xmm0
 ; SSE-NEXT:    retq
 ;
 ; VEX-LABEL: fptoui_2f64_to_2i8:
 ; VEX:       # %bb.0:
 ; VEX-NEXT:    vcvttpd2dq %xmm0, %xmm0
-; VEX-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
-; VEX-NEXT:    vpackuswb %xmm0, %xmm0, %xmm0
+; VEX-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,u,u,u,u,u,u,u,u,u,u,u,u,u,u]
 ; VEX-NEXT:    retq
 ;
 ; AVX512F-LABEL: fptoui_2f64_to_2i8:
 ; AVX512F:       # %bb.0:
 ; AVX512F-NEXT:    vcvttpd2dq %xmm0, %xmm0
-; AVX512F-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
-; AVX512F-NEXT:    vpackuswb %xmm0, %xmm0, %xmm0
+; AVX512F-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,u,u,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX512F-NEXT:    retq
 ;
 ; AVX512VL-LABEL: fptoui_2f64_to_2i8:
 ; AVX512VL:       # %bb.0:
 ; AVX512VL-NEXT:    vcvttpd2dq %xmm0, %xmm0
 ; AVX512VL-NEXT:    vpmovdb %xmm0, %xmm0
 ; AVX512VL-NEXT:    retq
 ;
 ; AVX512DQ-LABEL: fptoui_2f64_to_2i8:
 ; AVX512DQ:       # %bb.0:
 ; AVX512DQ-NEXT:    vcvttpd2dq %xmm0, %xmm0
-; AVX512DQ-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
-; AVX512DQ-NEXT:    vpackuswb %xmm0, %xmm0, %xmm0
+; AVX512DQ-NEXT:    vpshufb {{.*#+}} xmm0 = xmm0[0,4,u,u,u,u,u,u,u,u,u,u,u,u,u,u]
 ; AVX512DQ-NEXT:    retq
 ;
 ; AVX512VLDQ-LABEL: fptoui_2f64_to_2i8:
 ; AVX512VLDQ:       # %bb.0:
 ; AVX512VLDQ-NEXT:    vcvttpd2dq %xmm0, %xmm0
 ; AVX512VLDQ-NEXT:    vpmovdb %xmm0, %xmm0
 ; AVX512VLDQ-NEXT:    retq
   %cvt = fptoui <2 x double> %a to <2 x i8>
   ret <2 x i8> %cvt
 }
 
 define <2 x i16> @fptoui_2f64_to_2i16(<2 x double> %a) {
 ; SSE-LABEL: fptoui_2f64_to_2i16:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    cvttpd2dq %xmm0, %xmm0
 ; SSE-NEXT:    pshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; SSE-NEXT:    retq
 ;
 ; AVX-LABEL: fptoui_2f64_to_2i16:
 ; AVX:       # %bb.0:
 ; AVX-NEXT:    vcvttpd2dq %xmm0, %xmm0
-; AVX-NEXT:    vpackusdw %xmm0, %xmm0, %xmm0
+; AVX-NEXT:    vpshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
 ; AVX-NEXT:    retq
   %cvt = fptoui <2 x double> %a to <2 x i16>
   ret <2 x i16> %cvt
 }
 
 define <8 x i16> @fptosi_8f64_to_8i16(<8 x double> %a) {
 ; SSE-LABEL: fptosi_8f64_to_8i16:
 ; SSE:       # %bb.0:
-; SSE-NEXT:    cvttpd2dq %xmm3, %xmm3
-; SSE-NEXT:    cvttpd2dq %xmm2, %xmm2
-; SSE-NEXT:    unpcklpd {{.*#+}} xmm2 = xmm2[0],xmm3[0]
 ; SSE-NEXT:    cvttpd2dq %xmm1, %xmm1
 ; SSE-NEXT:    cvttpd2dq %xmm0, %xmm0
-; SSE-NEXT:    unpcklpd {{.*#+}} xmm0 = xmm0[0],xmm1[0]
-; SSE-NEXT:    packssdw %xmm2, %xmm0
+; SSE-NEXT:    punpcklwd {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3]
+; SSE-NEXT:    pshufd {{.*#+}} xmm0 = xmm0[0,2,2,3]
+; SSE-NEXT:    pshuflw {{.*#+}} xmm1 = xmm0[0,2,1,3,4,5,6,7]
+; SSE-NEXT:    cvttpd2dq %xmm3, %xmm0
+; SSE-NEXT:    cvttpd2dq %xmm2, %xmm2
+; SSE-NEXT:    punpcklwd {{.*#+}} xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1],xmm2[2],xmm0[2],xmm2[3],xmm0[3]
+; SSE-NEXT:    pshufd {{.*#+}} xmm0 = xmm2[0,1,2,0]
+; SSE-NEXT:    pshufhw {{.*#+}} xmm0 = xmm0[0,1,2,3,6,4,7,5]
+; SSE-NEXT:    movsd {{.*#+}} xmm0 = xmm1[0],xmm0[1]
 ; SSE-NEXT:    retq
 ;
 ; VEX-LABEL: fptosi_8f64_to_8i16:
 ; VEX:       # %bb.0:
 ; VEX-NEXT:    vcvttpd2dq %ymm1, %xmm1
+; VEX-NEXT:    vpxor %xmm2, %xmm2, %xmm2
+; VEX-NEXT:    vpblendw {{.*#+}} xmm1 = xmm1[0],xmm2[1],xmm1[2],xmm2[3],xmm1[4],xmm2[5],xmm1[6],xmm2[7]
 ; VEX-NEXT:    vcvttpd2dq %ymm0, %xmm0
-; VEX-NEXT:    vpackssdw %xmm1, %xmm0, %xmm0
+; VEX-NEXT:    vpblendw {{.*#+}} xmm0 = xmm0[0],xmm2[1],xmm0[2],xmm2[3],xmm0[4],xmm2[5],xmm0[6],xmm2[7]
+; VEX-NEXT:    vpackusdw %xmm1, %xmm0, %xmm0
 ; VEX-NEXT:    vzeroupper
 ; VEX-NEXT:    retq
 ;
 ; AVX512F-LABEL: fptosi_8f64_to_8i16:
 ; AVX512F:       # %bb.0:
 ; AVX512F-NEXT:    vcvttpd2dq %zmm0, %ymm0
 ; AVX512F-NEXT:    vpmovdw %zmm0, %ymm0
 ; AVX512F-NEXT:    # kill: def $xmm0 killed $xmm0 killed $ymm0

 ; AVX512VLDQ-NEXT:    retq
   %cvt = fptosi <8 x double> %a to <8 x i16>
   ret <8 x i16> %cvt
 }
 
 define <8 x i16> @fptoui_8f64_to_8i16(<8 x double> %a) {
 ; SSE-LABEL: fptoui_8f64_to_8i16:
 ; SSE:       # %bb.0:
-; SSE-NEXT:    cvttpd2dq %xmm3, %xmm3
-; SSE-NEXT:    cvttpd2dq %xmm2, %xmm2
-; SSE-NEXT:    unpcklpd {{.*#+}} xmm2 = xmm2[0],xmm3[0]
-; SSE-NEXT:    pshuflw {{.*#+}} xmm2 = xmm2[0,2,2,3,4,5,6,7]
-; SSE-NEXT:    pshufhw {{.*#+}} xmm2 = xmm2[0,1,2,3,4,6,6,7]
-; SSE-NEXT:    pshufd {{.*#+}} xmm2 = xmm2[0,2,2,3]
 ; SSE-NEXT:    cvttpd2dq %xmm1, %xmm1
 ; SSE-NEXT:    cvttpd2dq %xmm0, %xmm0
-; SSE-NEXT:    unpcklpd {{.*#+}} xmm0 = xmm0[0],xmm1[0]
-; SSE-NEXT:    pshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
-; SSE-NEXT:    pshufhw {{.*#+}} xmm0 = xmm0[0,1,2,3,4,6,6,7]
+; SSE-NEXT:    punpcklwd {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3]
 ; SSE-NEXT:    pshufd {{.*#+}} xmm0 = xmm0[0,2,2,3]
-; SSE-NEXT:    punpcklqdq {{.*#+}} xmm0 = xmm0[0],xmm2[0]
+; SSE-NEXT:    pshuflw {{.*#+}} xmm1 = xmm0[0,2,1,3,4,5,6,7]
+; SSE-NEXT:    cvttpd2dq %xmm3, %xmm0
+; SSE-NEXT:    cvttpd2dq %xmm2, %xmm2
+; SSE-NEXT:    punpcklwd {{.*#+}} xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1],xmm2[2],xmm0[2],xmm2[3],xmm0[3]
+; SSE-NEXT:    pshufd {{.*#+}} xmm0 = xmm2[0,1,2,0]
+; SSE-NEXT:    pshufhw {{.*#+}} xmm0 = xmm0[0,1,2,3,6,4,7,5]
+; SSE-NEXT:    movsd {{.*#+}} xmm0 = xmm1[0],xmm0[1]
 ; SSE-NEXT:    retq
 ;
 ; VEX-LABEL: fptoui_8f64_to_8i16:
 ; VEX:       # %bb.0:
 ; VEX-NEXT:    vcvttpd2dq %ymm1, %xmm1
+; VEX-NEXT:    vpxor %xmm2, %xmm2, %xmm2
+; VEX-NEXT:    vpblendw {{.*#+}} xmm1 = xmm1[0],xmm2[1],xmm1[2],xmm2[3],xmm1[4],xmm2[5],xmm1[6],xmm2[7]
 ; VEX-NEXT:    vcvttpd2dq %ymm0, %xmm0
+; VEX-NEXT:    vpblendw {{.*#+}} xmm0 = xmm0[0],xmm2[1],xmm0[2],xmm2[3],xmm0[4],xmm2[5],xmm0[6],xmm2[7]
 ; VEX-NEXT:    vpackusdw %xmm1, %xmm0, %xmm0
 ; VEX-NEXT:    vzeroupper
 ; VEX-NEXT:    retq
 ;
 ; AVX512F-LABEL: fptoui_8f64_to_8i16:
 ; AVX512F:       # %bb.0:
 ; AVX512F-NEXT:    vcvttpd2dq %zmm0, %ymm0
 ; AVX512F-NEXT:    vpmovdw %zmm0, %ymm0
; AVX512VLDQ-NEXT:    retq
   %cvt = fptoui <8 x double> %a to <8 x i16>
   ret <8 x i16> %cvt
 }
 
 define <16 x i8> @fptosi_16f32_to_16i8(<16 x float> %a) {
 ; SSE-LABEL: fptosi_16f32_to_16i8:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    cvttps2dq %xmm3, %xmm3
+; SSE-NEXT:    movdqa {{.*#+}} xmm4 = [255,0,255,0,255,0,255,0]
+; SSE-NEXT:    pand %xmm4, %xmm3
 ; SSE-NEXT:    cvttps2dq %xmm2, %xmm2
-; SSE-NEXT:    packssdw %xmm3, %xmm2
+; SSE-NEXT:    pand %xmm4, %xmm2
+; SSE-NEXT:    packuswb %xmm3, %xmm2
 ; SSE-NEXT:    cvttps2dq %xmm1, %xmm1
+; SSE-NEXT:    pand %xmm4, %xmm1
 ; SSE-NEXT:    cvttps2dq %xmm0, %xmm0
-; SSE-NEXT:    packssdw %xmm1, %xmm0
-; SSE-NEXT:    packsswb %xmm2, %xmm0
+; SSE-NEXT:    pand %xmm4, %xmm0
+; SSE-NEXT:    packuswb %xmm1, %xmm0
+; SSE-NEXT:    packuswb %xmm2, %xmm0
 ; SSE-NEXT:    retq
 ;
 ; AVX1-LABEL: fptosi_16f32_to_16i8:
 ; AVX1:       # %bb.0:
 ; AVX1-NEXT:    vcvttps2dq %ymm1, %ymm1
 ; AVX1-NEXT:    vextractf128 $1, %ymm1, %xmm2
-; AVX1-NEXT:    vpackssdw %xmm2, %xmm1, %xmm1
+; AVX1-NEXT:    vpxor %xmm3, %xmm3, %xmm3
+; AVX1-NEXT:    vpblendw {{.*#+}} xmm2 = xmm2[0],xmm3[1],xmm2[2],xmm3[3],xmm2[4],xmm3[5],xmm2[6],xmm3[7]
+; AVX1-NEXT:    vpblendw {{.*#+}} xmm1 = xmm1[0],xmm3[1],xmm1[2],xmm3[3],xmm1[4],xmm3[5],xmm1[6],xmm3[7]
+; AVX1-NEXT:    vpackusdw %xmm2, %xmm1, %xmm1
+; AVX1-NEXT:    vmovdqa {{.*#+}} xmm2 = [255,255,255,255,255,255,255,255]
+; AVX1-NEXT:    vpand %xmm2, %xmm1, %xmm1
 ; AVX1-NEXT:    vcvttps2dq %ymm0, %ymm0
-; AVX1-NEXT:    vextractf128 $1, %ymm0, %xmm2
-; AVX1-NEXT:    vpackssdw %xmm2, %xmm0, %xmm0
-; AVX1-NEXT:    vpacksswb %xmm1, %xmm0, %xmm0
+; AVX1-NEXT:    vextractf128 $1, %ymm0, %xmm4
+; AVX1-NEXT:    vpblendw {{.*#+}} xmm4 = xmm4[0],xmm3[1],xmm4[2],xmm3[3],xmm4[4],xmm3[5],xmm4[6],xmm3[7]
+; AVX1-NEXT:    vpblendw {{.*#+}} xmm0 = xmm0[0],xmm3[1],xmm0[2],xmm3[3],xmm0[4],xmm3[5],xmm0[6],xmm3[7]
+; AVX1-NEXT:    vpackusdw %xmm4, %xmm0, %xmm0
+; AVX1-NEXT:    vpand %xmm2, %xmm0, %xmm0
+; AVX1-NEXT:    vpackuswb %xmm1, %xmm0, %xmm0
 ; AVX1-NEXT:    vzeroupper
 ; AVX1-NEXT:    retq
 ;
 ; AVX2-LABEL: fptosi_16f32_to_16i8:
 ; AVX2:       # %bb.0:
 ; AVX2-NEXT:    vcvttps2dq %ymm1, %ymm1
-; AVX2-NEXT:    vextracti128 $1, %ymm1, %xmm2
-; AVX2-NEXT:    vpackssdw %xmm2, %xmm1, %xmm1
+; AVX2-NEXT:    vmovdqa {{.*#+}} ymm2 = [0,1,4,5,8,9,12,13,8,9,12,13,12,13,14,15,16,17,20,21,24,25,28,29,24,25,28,29,28,29,30,31]
+; AVX2-NEXT:    vpshufb %ymm2, %ymm1, %ymm1
+; AVX2-NEXT:    vpermq {{.*#+}} ymm1 = ymm1[0,2,2,3]
+; AVX2-NEXT:    vmovdqa {{.*#+}} xmm3 = [255,255,255,255,255,255,255,255]
+; AVX2-NEXT:    vpand %xmm3, %xmm1, %xmm1
 ; AVX2-NEXT:    vcvttps2dq %ymm0, %ymm0
-; AVX2-NEXT:    vextracti128 $1, %ymm0, %xmm2
-; AVX2-NEXT:    vpackssdw %xmm2, %xmm0, %xmm0
-; AVX2-NEXT:    vpacksswb %xmm1, %xmm0, %xmm0
+; AVX2-NEXT:    vpshufb %ymm2, %ymm0, %ymm0
+; AVX2-NEXT:    vpermq {{.*#+}} ymm0 = ymm0[0,2,2,3]
+; AVX2-NEXT:    vpand %xmm3, %xmm0, %xmm0
+; AVX2-NEXT:    vpackuswb %xmm1, %xmm0, %xmm0
 ; AVX2-NEXT:    vzeroupper
 ; AVX2-NEXT:    retq
 ;
 ; AVX512-LABEL: fptosi_16f32_to_16i8:
 ; AVX512:       # %bb.0:
 ; AVX512-NEXT:    vcvttps2dq %zmm0, %zmm0
 ; AVX512-NEXT:    vpmovdb %zmm0, %xmm0
 ; AVX512-NEXT:    vzeroupper
 ; AVX512-NEXT:    retq
   %cvt = fptosi <16 x float> %a to <16 x i8>
   ret <16 x i8> %cvt
 }
 
 define <16 x i8> @fptoui_16f32_to_16i8(<16 x float> %a) {
 ; SSE-LABEL: fptoui_16f32_to_16i8:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    cvttps2dq %xmm3, %xmm3
+; SSE-NEXT:    movdqa {{.*#+}} xmm4 = [255,0,255,0,255,0,255,0]
+; SSE-NEXT:    pand %xmm4, %xmm3
 ; SSE-NEXT:    cvttps2dq %xmm2, %xmm2
-; SSE-NEXT:    packssdw %xmm3, %xmm2
+; SSE-NEXT:    pand %xmm4, %xmm2
+; SSE-NEXT:    packuswb %xmm3, %xmm2
 ; SSE-NEXT:    cvttps2dq %xmm1, %xmm1
+; SSE-NEXT:    pand %xmm4, %xmm1
 ; SSE-NEXT:    cvttps2dq %xmm0, %xmm0
-; SSE-NEXT:    packssdw %xmm1, %xmm0
+; SSE-NEXT:    pand %xmm4, %xmm0
+; SSE-NEXT:    packuswb %xmm1, %xmm0
 ; SSE-NEXT:    packuswb %xmm2, %xmm0
 ; SSE-NEXT:    retq
 ;
 ; AVX1-LABEL: fptoui_16f32_to_16i8:
 ; AVX1:       # %bb.0:
 ; AVX1-NEXT:    vcvttps2dq %ymm1, %ymm1
 ; AVX1-NEXT:    vextractf128 $1, %ymm1, %xmm2
-; AVX1-NEXT:    vpackssdw %xmm2, %xmm1, %xmm1
+; AVX1-NEXT:    vpxor %xmm3, %xmm3, %xmm3
+; AVX1-NEXT:    vpblendw {{.*#+}} xmm2 = xmm2[0],xmm3[1],xmm2[2],xmm3[3],xmm2[4],xmm3[5],xmm2[6],xmm3[7]
+; AVX1-NEXT:    vpblendw {{.*#+}} xmm1 = xmm1[0],xmm3[1],xmm1[2],xmm3[3],xmm1[4],xmm3[5],xmm1[6],xmm3[7]
+; AVX1-NEXT:    vpackusdw %xmm2, %xmm1, %xmm1
+; AVX1-NEXT:    vmovdqa {{.*#+}} xmm2 = [255,255,255,255,255,255,255,255]
+; AVX1-NEXT:    vpand %xmm2, %xmm1, %xmm1
 ; AVX1-NEXT:    vcvttps2dq %ymm0, %ymm0
-; AVX1-NEXT:    vextractf128 $1, %ymm0, %xmm2
-; AVX1-NEXT:    vpackssdw %xmm2, %xmm0, %xmm0
+; AVX1-NEXT:    vextractf128 $1, %ymm0, %xmm4
+; AVX1-NEXT:    vpblendw {{.*#+}} xmm4 = xmm4[0],xmm3[1],xmm4[2],xmm3[3],xmm4[4],xmm3[5],xmm4[6],xmm3[7]
+; AVX1-NEXT:    vpblendw {{.*#+}} xmm0 = xmm0[0],xmm3[1],xmm0[2],xmm3[3],xmm0[4],xmm3[5],xmm0[6],xmm3[7]
+; AVX1-NEXT:    vpackusdw %xmm4, %xmm0, %xmm0
+; AVX1-NEXT:    vpand %xmm2, %xmm0, %xmm0
 ; AVX1-NEXT:    vpackuswb %xmm1, %xmm0, %xmm0
 ; AVX1-NEXT:    vzeroupper
 ; AVX1-NEXT:    retq
 ;
 ; AVX2-LABEL: fptoui_16f32_to_16i8:
 ; AVX2:       # %bb.0:
 ; AVX2-NEXT:    vcvttps2dq %ymm1, %ymm1
-; AVX2-NEXT:    vextracti128 $1, %ymm1, %xmm2
-; AVX2-NEXT:    vpackssdw %xmm2, %xmm1, %xmm1
+; AVX2-NEXT:    vmovdqa {{.*#+}} ymm2 = [0,1,4,5,8,9,12,13,8,9,12,13,12,13,14,15,16,17,20,21,24,25,28,29,24,25,28,29,28,29,30,31]
+; AVX2-NEXT:    vpshufb %ymm2, %ymm1, %ymm1
+; AVX2-NEXT:    vpermq {{.*#+}} ymm1 = ymm1[0,2,2,3]
+; AVX2-NEXT:    vmovdqa {{.*#+}} xmm3 = [255,255,255,255,255,255,255,255]
+; AVX2-NEXT:    vpand %xmm3, %xmm1, %xmm1
 ; AVX2-NEXT:    vcvttps2dq %ymm0, %ymm0
-; AVX2-NEXT:    vextracti128 $1, %ymm0, %xmm2
-; AVX2-NEXT:    vpackssdw %xmm2, %xmm0, %xmm0
+; AVX2-NEXT:    vpshufb %ymm2, %ymm0, %ymm0
+; AVX2-NEXT:    vpermq {{.*#+}} ymm0 = ymm0[0,2,2,3]
+; AVX2-NEXT:    vpand %xmm3, %xmm0, %xmm0
 ; AVX2-NEXT:    vpackuswb %xmm1, %xmm0, %xmm0
 ; AVX2-NEXT:    vzeroupper
 ; AVX2-NEXT:    retq
 ;
 ; AVX512-LABEL: fptoui_16f32_to_16i8:
 ; AVX512:       # %bb.0:
 ; AVX512-NEXT:    vcvttps2dq %zmm0, %zmm0
 ; AVX512-NEXT:    vpmovdb %zmm0, %xmm0