830 lines
24 KiB
Plaintext
830 lines
24 KiB
Plaintext
//===---------------------------------------------------------------------===//
|
|
// Random ideas for the X86 backend: SSE-specific stuff.
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
SSE Variable shift can be custom lowered to something like this, which uses a
|
|
small table + unaligned load + shuffle instead of going through memory.
|
|
|
|
__m128i_shift_right:
|
|
.byte 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
|
|
.byte -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
|
|
|
|
...
|
|
__m128i shift_right(__m128i value, unsigned long offset) {
|
|
return _mm_shuffle_epi8(value,
|
|
_mm_loadu_si128((__m128 *) (___m128i_shift_right + offset)));
|
|
}
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
SSE has instructions for doing operations on complex numbers, we should pattern
|
|
match them. For example, this should turn into a horizontal add:
|
|
|
|
typedef float __attribute__((vector_size(16))) v4f32;
|
|
float f32(v4f32 A) {
|
|
return A[0]+A[1]+A[2]+A[3];
|
|
}
|
|
|
|
Instead we get this:
|
|
|
|
_f32: ## @f32
|
|
pshufd $1, %xmm0, %xmm1 ## xmm1 = xmm0[1,0,0,0]
|
|
addss %xmm0, %xmm1
|
|
pshufd $3, %xmm0, %xmm2 ## xmm2 = xmm0[3,0,0,0]
|
|
movhlps %xmm0, %xmm0 ## xmm0 = xmm0[1,1]
|
|
movaps %xmm0, %xmm3
|
|
addss %xmm1, %xmm3
|
|
movdqa %xmm2, %xmm0
|
|
addss %xmm3, %xmm0
|
|
ret
|
|
|
|
Also, there are cases where some simple local SLP would improve codegen a bit.
|
|
compiling this:
|
|
|
|
_Complex float f32(_Complex float A, _Complex float B) {
|
|
return A+B;
|
|
}
|
|
|
|
into:
|
|
|
|
_f32: ## @f32
|
|
movdqa %xmm0, %xmm2
|
|
addss %xmm1, %xmm2
|
|
pshufd $1, %xmm1, %xmm1 ## xmm1 = xmm1[1,0,0,0]
|
|
pshufd $1, %xmm0, %xmm3 ## xmm3 = xmm0[1,0,0,0]
|
|
addss %xmm1, %xmm3
|
|
movaps %xmm2, %xmm0
|
|
unpcklps %xmm3, %xmm0 ## xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
|
|
ret
|
|
|
|
seems silly when it could just be one addps.
|
|
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
Expand libm rounding functions inline: Significant speedups possible.
|
|
http://gcc.gnu.org/ml/gcc-patches/2006-10/msg00909.html
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
When compiled with unsafemath enabled, "main" should enable SSE DAZ mode and
|
|
other fast SSE modes.
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
Think about doing i64 math in SSE regs on x86-32.
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
This testcase should have no SSE instructions in it, and only one load from
|
|
a constant pool:
|
|
|
|
double %test3(bool %B) {
|
|
%C = select bool %B, double 123.412, double 523.01123123
|
|
ret double %C
|
|
}
|
|
|
|
Currently, the select is being lowered, which prevents the dag combiner from
|
|
turning 'select (load CPI1), (load CPI2)' -> 'load (select CPI1, CPI2)'
|
|
|
|
The pattern isel got this one right.
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
Lower memcpy / memset to a series of SSE 128 bit move instructions when it's
|
|
feasible.
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
Codegen:
|
|
if (copysign(1.0, x) == copysign(1.0, y))
|
|
into:
|
|
if (x^y & mask)
|
|
when using SSE.
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
Use movhps to update upper 64-bits of a v4sf value. Also movlps on lower half
|
|
of a v4sf value.
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
Better codegen for vector_shuffles like this { x, 0, 0, 0 } or { x, 0, x, 0}.
|
|
Perhaps use pxor / xorp* to clear a XMM register first?
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
External test Nurbs exposed some problems. Look for
|
|
__ZN15Nurbs_SSE_Cubic17TessellateSurfaceE, bb cond_next140. This is what icc
|
|
emits:
|
|
|
|
movaps (%edx), %xmm2 #59.21
|
|
movaps (%edx), %xmm5 #60.21
|
|
movaps (%edx), %xmm4 #61.21
|
|
movaps (%edx), %xmm3 #62.21
|
|
movl 40(%ecx), %ebp #69.49
|
|
shufps $0, %xmm2, %xmm5 #60.21
|
|
movl 100(%esp), %ebx #69.20
|
|
movl (%ebx), %edi #69.20
|
|
imull %ebp, %edi #69.49
|
|
addl (%eax), %edi #70.33
|
|
shufps $85, %xmm2, %xmm4 #61.21
|
|
shufps $170, %xmm2, %xmm3 #62.21
|
|
shufps $255, %xmm2, %xmm2 #63.21
|
|
lea (%ebp,%ebp,2), %ebx #69.49
|
|
negl %ebx #69.49
|
|
lea -3(%edi,%ebx), %ebx #70.33
|
|
shll $4, %ebx #68.37
|
|
addl 32(%ecx), %ebx #68.37
|
|
testb $15, %bl #91.13
|
|
jne L_B1.24 # Prob 5% #91.13
|
|
|
|
This is the llvm code after instruction scheduling:
|
|
|
|
cond_next140 (0xa910740, LLVM BB @0xa90beb0):
|
|
%reg1078 = MOV32ri -3
|
|
%reg1079 = ADD32rm %reg1078, %reg1068, 1, %noreg, 0
|
|
%reg1037 = MOV32rm %reg1024, 1, %noreg, 40
|
|
%reg1080 = IMUL32rr %reg1079, %reg1037
|
|
%reg1081 = MOV32rm %reg1058, 1, %noreg, 0
|
|
%reg1038 = LEA32r %reg1081, 1, %reg1080, -3
|
|
%reg1036 = MOV32rm %reg1024, 1, %noreg, 32
|
|
%reg1082 = SHL32ri %reg1038, 4
|
|
%reg1039 = ADD32rr %reg1036, %reg1082
|
|
%reg1083 = MOVAPSrm %reg1059, 1, %noreg, 0
|
|
%reg1034 = SHUFPSrr %reg1083, %reg1083, 170
|
|
%reg1032 = SHUFPSrr %reg1083, %reg1083, 0
|
|
%reg1035 = SHUFPSrr %reg1083, %reg1083, 255
|
|
%reg1033 = SHUFPSrr %reg1083, %reg1083, 85
|
|
%reg1040 = MOV32rr %reg1039
|
|
%reg1084 = AND32ri8 %reg1039, 15
|
|
CMP32ri8 %reg1084, 0
|
|
JE mbb<cond_next204,0xa914d30>
|
|
|
|
Still ok. After register allocation:
|
|
|
|
cond_next140 (0xa910740, LLVM BB @0xa90beb0):
|
|
%eax = MOV32ri -3
|
|
%edx = MOV32rm %stack.3, 1, %noreg, 0
|
|
ADD32rm %eax<def&use>, %edx, 1, %noreg, 0
|
|
%edx = MOV32rm %stack.7, 1, %noreg, 0
|
|
%edx = MOV32rm %edx, 1, %noreg, 40
|
|
IMUL32rr %eax<def&use>, %edx
|
|
%esi = MOV32rm %stack.5, 1, %noreg, 0
|
|
%esi = MOV32rm %esi, 1, %noreg, 0
|
|
MOV32mr %stack.4, 1, %noreg, 0, %esi
|
|
%eax = LEA32r %esi, 1, %eax, -3
|
|
%esi = MOV32rm %stack.7, 1, %noreg, 0
|
|
%esi = MOV32rm %esi, 1, %noreg, 32
|
|
%edi = MOV32rr %eax
|
|
SHL32ri %edi<def&use>, 4
|
|
ADD32rr %edi<def&use>, %esi
|
|
%xmm0 = MOVAPSrm %ecx, 1, %noreg, 0
|
|
%xmm1 = MOVAPSrr %xmm0
|
|
SHUFPSrr %xmm1<def&use>, %xmm1, 170
|
|
%xmm2 = MOVAPSrr %xmm0
|
|
SHUFPSrr %xmm2<def&use>, %xmm2, 0
|
|
%xmm3 = MOVAPSrr %xmm0
|
|
SHUFPSrr %xmm3<def&use>, %xmm3, 255
|
|
SHUFPSrr %xmm0<def&use>, %xmm0, 85
|
|
%ebx = MOV32rr %edi
|
|
AND32ri8 %ebx<def&use>, 15
|
|
CMP32ri8 %ebx, 0
|
|
JE mbb<cond_next204,0xa914d30>
|
|
|
|
This looks really bad. The problem is shufps is a destructive opcode. Since it
|
|
appears as operand two in more than one shufps ops. It resulted in a number of
|
|
copies. Note icc also suffers from the same problem. Either the instruction
|
|
selector should select pshufd or The register allocator can made the two-address
|
|
to three-address transformation.
|
|
|
|
It also exposes some other problems. See MOV32ri -3 and the spills.
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
Consider:
|
|
|
|
__m128 test(float a) {
|
|
return _mm_set_ps(0.0, 0.0, 0.0, a*a);
|
|
}
|
|
|
|
This compiles into:
|
|
|
|
movss 4(%esp), %xmm1
|
|
mulss %xmm1, %xmm1
|
|
xorps %xmm0, %xmm0
|
|
movss %xmm1, %xmm0
|
|
ret
|
|
|
|
Because mulss doesn't modify the top 3 elements, the top elements of
|
|
xmm1 are already zero'd. We could compile this to:
|
|
|
|
movss 4(%esp), %xmm0
|
|
mulss %xmm0, %xmm0
|
|
ret
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
Here's a sick and twisted idea. Consider code like this:
|
|
|
|
__m128 test(__m128 a) {
|
|
float b = *(float*)&A;
|
|
...
|
|
return _mm_set_ps(0.0, 0.0, 0.0, b);
|
|
}
|
|
|
|
This might compile to this code:
|
|
|
|
movaps c(%esp), %xmm1
|
|
xorps %xmm0, %xmm0
|
|
movss %xmm1, %xmm0
|
|
ret
|
|
|
|
Now consider if the ... code caused xmm1 to get spilled. This might produce
|
|
this code:
|
|
|
|
movaps c(%esp), %xmm1
|
|
movaps %xmm1, c2(%esp)
|
|
...
|
|
|
|
xorps %xmm0, %xmm0
|
|
movaps c2(%esp), %xmm1
|
|
movss %xmm1, %xmm0
|
|
ret
|
|
|
|
However, since the reload is only used by these instructions, we could
|
|
"fold" it into the uses, producing something like this:
|
|
|
|
movaps c(%esp), %xmm1
|
|
movaps %xmm1, c2(%esp)
|
|
...
|
|
|
|
movss c2(%esp), %xmm0
|
|
ret
|
|
|
|
... saving two instructions.
|
|
|
|
The basic idea is that a reload from a spill slot, can, if only one 4-byte
|
|
chunk is used, bring in 3 zeros the one element instead of 4 elements.
|
|
This can be used to simplify a variety of shuffle operations, where the
|
|
elements are fixed zeros.
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
This code generates ugly code, probably due to costs being off or something:
|
|
|
|
define void @test(float* %P, <4 x float>* %P2 ) {
|
|
%xFloat0.688 = load float* %P
|
|
%tmp = load <4 x float>* %P2
|
|
%inFloat3.713 = insertelement <4 x float> %tmp, float 0.0, i32 3
|
|
store <4 x float> %inFloat3.713, <4 x float>* %P2
|
|
ret void
|
|
}
|
|
|
|
Generates:
|
|
|
|
_test:
|
|
movl 8(%esp), %eax
|
|
movaps (%eax), %xmm0
|
|
pxor %xmm1, %xmm1
|
|
movaps %xmm0, %xmm2
|
|
shufps $50, %xmm1, %xmm2
|
|
shufps $132, %xmm2, %xmm0
|
|
movaps %xmm0, (%eax)
|
|
ret
|
|
|
|
Would it be better to generate:
|
|
|
|
_test:
|
|
movl 8(%esp), %ecx
|
|
movaps (%ecx), %xmm0
|
|
xor %eax, %eax
|
|
pinsrw $6, %eax, %xmm0
|
|
pinsrw $7, %eax, %xmm0
|
|
movaps %xmm0, (%ecx)
|
|
ret
|
|
|
|
?
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
Some useful information in the Apple Altivec / SSE Migration Guide:
|
|
|
|
http://developer.apple.com/documentation/Performance/Conceptual/
|
|
Accelerate_sse_migration/index.html
|
|
|
|
e.g. SSE select using and, andnot, or. Various SSE compare translations.
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
Add hooks to commute some CMPP operations.
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
Apply the same transformation that merged four float into a single 128-bit load
|
|
to loads from constant pool.
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
Floating point max / min are commutable when -enable-unsafe-fp-path is
|
|
specified. We should turn int_x86_sse_max_ss and X86ISD::FMIN etc. into other
|
|
nodes which are selected to max / min instructions that are marked commutable.
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
We should materialize vector constants like "all ones" and "signbit" with
|
|
code like:
|
|
|
|
cmpeqps xmm1, xmm1 ; xmm1 = all-ones
|
|
|
|
and:
|
|
cmpeqps xmm1, xmm1 ; xmm1 = all-ones
|
|
psrlq xmm1, 31 ; xmm1 = all 100000000000...
|
|
|
|
instead of using a load from the constant pool. The later is important for
|
|
ABS/NEG/copysign etc.
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
These functions:
|
|
|
|
#include <xmmintrin.h>
|
|
__m128i a;
|
|
void x(unsigned short n) {
|
|
a = _mm_slli_epi32 (a, n);
|
|
}
|
|
void y(unsigned n) {
|
|
a = _mm_slli_epi32 (a, n);
|
|
}
|
|
|
|
compile to ( -O3 -static -fomit-frame-pointer):
|
|
_x:
|
|
movzwl 4(%esp), %eax
|
|
movd %eax, %xmm0
|
|
movaps _a, %xmm1
|
|
pslld %xmm0, %xmm1
|
|
movaps %xmm1, _a
|
|
ret
|
|
_y:
|
|
movd 4(%esp), %xmm0
|
|
movaps _a, %xmm1
|
|
pslld %xmm0, %xmm1
|
|
movaps %xmm1, _a
|
|
ret
|
|
|
|
"y" looks good, but "x" does silly movzwl stuff around into a GPR. It seems
|
|
like movd would be sufficient in both cases as the value is already zero
|
|
extended in the 32-bit stack slot IIRC. For signed short, it should also be
|
|
save, as a really-signed value would be undefined for pslld.
|
|
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
#include <math.h>
|
|
int t1(double d) { return signbit(d); }
|
|
|
|
This currently compiles to:
|
|
subl $12, %esp
|
|
movsd 16(%esp), %xmm0
|
|
movsd %xmm0, (%esp)
|
|
movl 4(%esp), %eax
|
|
shrl $31, %eax
|
|
addl $12, %esp
|
|
ret
|
|
|
|
We should use movmskp{s|d} instead.
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
CodeGen/X86/vec_align.ll tests whether we can turn 4 scalar loads into a single
|
|
(aligned) vector load. This functionality has a couple of problems.
|
|
|
|
1. The code to infer alignment from loads of globals is in the X86 backend,
|
|
not the dag combiner. This is because dagcombine2 needs to be able to see
|
|
through the X86ISD::Wrapper node, which DAGCombine can't really do.
|
|
2. The code for turning 4 x load into a single vector load is target
|
|
independent and should be moved to the dag combiner.
|
|
3. The code for turning 4 x load into a vector load can only handle a direct
|
|
load from a global or a direct load from the stack. It should be generalized
|
|
to handle any load from P, P+4, P+8, P+12, where P can be anything.
|
|
4. The alignment inference code cannot handle loads from globals in non-static
|
|
mode because it doesn't look through the extra dyld stub load. If you try
|
|
vec_align.ll without -relocation-model=static, you'll see what I mean.
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
We should lower store(fneg(load p), q) into an integer load+xor+store, which
|
|
eliminates a constant pool load. For example, consider:
|
|
|
|
define i64 @ccosf(float %z.0, float %z.1) nounwind readonly {
|
|
entry:
|
|
%tmp6 = fsub float -0.000000e+00, %z.1 ; <float> [#uses=1]
|
|
%tmp20 = tail call i64 @ccoshf( float %tmp6, float %z.0 ) nounwind readonly
|
|
ret i64 %tmp20
|
|
}
|
|
declare i64 @ccoshf(float %z.0, float %z.1) nounwind readonly
|
|
|
|
This currently compiles to:
|
|
|
|
LCPI1_0: # <4 x float>
|
|
.long 2147483648 # float -0
|
|
.long 2147483648 # float -0
|
|
.long 2147483648 # float -0
|
|
.long 2147483648 # float -0
|
|
_ccosf:
|
|
subl $12, %esp
|
|
movss 16(%esp), %xmm0
|
|
movss %xmm0, 4(%esp)
|
|
movss 20(%esp), %xmm0
|
|
xorps LCPI1_0, %xmm0
|
|
movss %xmm0, (%esp)
|
|
call L_ccoshf$stub
|
|
addl $12, %esp
|
|
ret
|
|
|
|
Note the load into xmm0, then xor (to negate), then store. In PIC mode,
|
|
this code computes the pic base and does two loads to do the constant pool
|
|
load, so the improvement is much bigger.
|
|
|
|
The tricky part about this xform is that the argument load/store isn't exposed
|
|
until post-legalize, and at that point, the fneg has been custom expanded into
|
|
an X86 fxor. This means that we need to handle this case in the x86 backend
|
|
instead of in target independent code.
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
Non-SSE4 insert into 16 x i8 is atrociously bad.
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
<2 x i64> extract is substantially worse than <2 x f64>, even if the destination
|
|
is memory.
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
INSERTPS can match any insert (extract, imm1), imm2 for 4 x float, and insert
|
|
any number of 0.0 simultaneously. Currently we only use it for simple
|
|
insertions.
|
|
|
|
See comments in LowerINSERT_VECTOR_ELT_SSE4.
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
On a random note, SSE2 should declare insert/extract of 2 x f64 as legal, not
|
|
Custom. All combinations of insert/extract reg-reg, reg-mem, and mem-reg are
|
|
legal, it'll just take a few extra patterns written in the .td file.
|
|
|
|
Note: this is not a code quality issue; the custom lowered code happens to be
|
|
right, but we shouldn't have to custom lower anything. This is probably related
|
|
to <2 x i64> ops being so bad.
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
LLVM currently generates stack realignment code, when it is not necessary
|
|
needed. The problem is that we need to know about stack alignment too early,
|
|
before RA runs.
|
|
|
|
At that point we don't know, whether there will be vector spill, or not.
|
|
Stack realignment logic is overly conservative here, but otherwise we can
|
|
produce unaligned loads/stores.
|
|
|
|
Fixing this will require some huge RA changes.
|
|
|
|
Testcase:
|
|
#include <emmintrin.h>
|
|
|
|
typedef short vSInt16 __attribute__ ((__vector_size__ (16)));
|
|
|
|
static const vSInt16 a = {- 22725, - 12873, - 22725, - 12873, - 22725, - 12873,
|
|
- 22725, - 12873};;
|
|
|
|
vSInt16 madd(vSInt16 b)
|
|
{
|
|
return _mm_madd_epi16(a, b);
|
|
}
|
|
|
|
Generated code (x86-32, linux):
|
|
madd:
|
|
pushl %ebp
|
|
movl %esp, %ebp
|
|
andl $-16, %esp
|
|
movaps .LCPI1_0, %xmm1
|
|
pmaddwd %xmm1, %xmm0
|
|
movl %ebp, %esp
|
|
popl %ebp
|
|
ret
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
Consider:
|
|
#include <emmintrin.h>
|
|
__m128 foo2 (float x) {
|
|
return _mm_set_ps (0, 0, x, 0);
|
|
}
|
|
|
|
In x86-32 mode, we generate this spiffy code:
|
|
|
|
_foo2:
|
|
movss 4(%esp), %xmm0
|
|
pshufd $81, %xmm0, %xmm0
|
|
ret
|
|
|
|
in x86-64 mode, we generate this code, which could be better:
|
|
|
|
_foo2:
|
|
xorps %xmm1, %xmm1
|
|
movss %xmm0, %xmm1
|
|
pshufd $81, %xmm1, %xmm0
|
|
ret
|
|
|
|
In sse4 mode, we could use insertps to make both better.
|
|
|
|
Here's another testcase that could use insertps [mem]:
|
|
|
|
#include <xmmintrin.h>
|
|
extern float x2, x3;
|
|
__m128 foo1 (float x1, float x4) {
|
|
return _mm_set_ps (x2, x1, x3, x4);
|
|
}
|
|
|
|
gcc mainline compiles it to:
|
|
|
|
foo1:
|
|
insertps $0x10, x2(%rip), %xmm0
|
|
insertps $0x10, x3(%rip), %xmm1
|
|
movaps %xmm1, %xmm2
|
|
movlhps %xmm0, %xmm2
|
|
movaps %xmm2, %xmm0
|
|
ret
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
We compile vector multiply-by-constant into poor code:
|
|
|
|
define <4 x i32> @f(<4 x i32> %i) nounwind {
|
|
%A = mul <4 x i32> %i, < i32 10, i32 10, i32 10, i32 10 >
|
|
ret <4 x i32> %A
|
|
}
|
|
|
|
On targets without SSE4.1, this compiles into:
|
|
|
|
LCPI1_0: ## <4 x i32>
|
|
.long 10
|
|
.long 10
|
|
.long 10
|
|
.long 10
|
|
.text
|
|
.align 4,0x90
|
|
.globl _f
|
|
_f:
|
|
pshufd $3, %xmm0, %xmm1
|
|
movd %xmm1, %eax
|
|
imull LCPI1_0+12, %eax
|
|
movd %eax, %xmm1
|
|
pshufd $1, %xmm0, %xmm2
|
|
movd %xmm2, %eax
|
|
imull LCPI1_0+4, %eax
|
|
movd %eax, %xmm2
|
|
punpckldq %xmm1, %xmm2
|
|
movd %xmm0, %eax
|
|
imull LCPI1_0, %eax
|
|
movd %eax, %xmm1
|
|
movhlps %xmm0, %xmm0
|
|
movd %xmm0, %eax
|
|
imull LCPI1_0+8, %eax
|
|
movd %eax, %xmm0
|
|
punpckldq %xmm0, %xmm1
|
|
movaps %xmm1, %xmm0
|
|
punpckldq %xmm2, %xmm0
|
|
ret
|
|
|
|
It would be better to synthesize integer vector multiplication by constants
|
|
using shifts and adds, pslld and paddd here. And even on targets with SSE4.1,
|
|
simple cases such as multiplication by powers of two would be better as
|
|
vector shifts than as multiplications.
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
We compile this:
|
|
|
|
__m128i
|
|
foo2 (char x)
|
|
{
|
|
return _mm_set_epi8 (1, 0, 0, 0, 0, 0, 0, 0, 0, x, 0, 1, 0, 0, 0, 0);
|
|
}
|
|
|
|
into:
|
|
movl $1, %eax
|
|
xorps %xmm0, %xmm0
|
|
pinsrw $2, %eax, %xmm0
|
|
movzbl 4(%esp), %eax
|
|
pinsrw $3, %eax, %xmm0
|
|
movl $256, %eax
|
|
pinsrw $7, %eax, %xmm0
|
|
ret
|
|
|
|
|
|
gcc-4.2:
|
|
subl $12, %esp
|
|
movzbl 16(%esp), %eax
|
|
movdqa LC0, %xmm0
|
|
pinsrw $3, %eax, %xmm0
|
|
addl $12, %esp
|
|
ret
|
|
.const
|
|
.align 4
|
|
LC0:
|
|
.word 0
|
|
.word 0
|
|
.word 1
|
|
.word 0
|
|
.word 0
|
|
.word 0
|
|
.word 0
|
|
.word 256
|
|
|
|
With SSE4, it should be
|
|
movdqa .LC0(%rip), %xmm0
|
|
pinsrb $6, %edi, %xmm0
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
We should transform a shuffle of two vectors of constants into a single vector
|
|
of constants. Also, insertelement of a constant into a vector of constants
|
|
should also result in a vector of constants. e.g. 2008-06-25-VecISelBug.ll.
|
|
|
|
We compiled it to something horrible:
|
|
|
|
.align 4
|
|
LCPI1_1: ## float
|
|
.long 1065353216 ## float 1
|
|
.const
|
|
|
|
.align 4
|
|
LCPI1_0: ## <4 x float>
|
|
.space 4
|
|
.long 1065353216 ## float 1
|
|
.space 4
|
|
.long 1065353216 ## float 1
|
|
.text
|
|
.align 4,0x90
|
|
.globl _t
|
|
_t:
|
|
xorps %xmm0, %xmm0
|
|
movhps LCPI1_0, %xmm0
|
|
movss LCPI1_1, %xmm1
|
|
movaps %xmm0, %xmm2
|
|
shufps $2, %xmm1, %xmm2
|
|
shufps $132, %xmm2, %xmm0
|
|
movaps %xmm0, 0
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
rdar://5907648
|
|
|
|
This function:
|
|
|
|
float foo(unsigned char x) {
|
|
return x;
|
|
}
|
|
|
|
compiles to (x86-32):
|
|
|
|
define float @foo(i8 zeroext %x) nounwind {
|
|
%tmp12 = uitofp i8 %x to float ; <float> [#uses=1]
|
|
ret float %tmp12
|
|
}
|
|
|
|
compiles to:
|
|
|
|
_foo:
|
|
subl $4, %esp
|
|
movzbl 8(%esp), %eax
|
|
cvtsi2ss %eax, %xmm0
|
|
movss %xmm0, (%esp)
|
|
flds (%esp)
|
|
addl $4, %esp
|
|
ret
|
|
|
|
We should be able to use:
|
|
cvtsi2ss 8($esp), %xmm0
|
|
since we know the stack slot is already zext'd.
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
Consider using movlps instead of movsd to implement (scalar_to_vector (loadf64))
|
|
when code size is critical. movlps is slower than movsd on core2 but it's one
|
|
byte shorter.
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
We should use a dynamic programming based approach to tell when using FPStack
|
|
operations is cheaper than SSE. SciMark montecarlo contains code like this
|
|
for example:
|
|
|
|
double MonteCarlo_num_flops(int Num_samples) {
|
|
return ((double) Num_samples)* 4.0;
|
|
}
|
|
|
|
In fpstack mode, this compiles into:
|
|
|
|
LCPI1_0:
|
|
.long 1082130432 ## float 4.000000e+00
|
|
_MonteCarlo_num_flops:
|
|
subl $4, %esp
|
|
movl 8(%esp), %eax
|
|
movl %eax, (%esp)
|
|
fildl (%esp)
|
|
fmuls LCPI1_0
|
|
addl $4, %esp
|
|
ret
|
|
|
|
in SSE mode, it compiles into significantly slower code:
|
|
|
|
_MonteCarlo_num_flops:
|
|
subl $12, %esp
|
|
cvtsi2sd 16(%esp), %xmm0
|
|
mulsd LCPI1_0, %xmm0
|
|
movsd %xmm0, (%esp)
|
|
fldl (%esp)
|
|
addl $12, %esp
|
|
ret
|
|
|
|
There are also other cases in scimark where using fpstack is better, it is
|
|
cheaper to do fld1 than load from a constant pool for example, so
|
|
"load, add 1.0, store" is better done in the fp stack, etc.
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
These should compile into the same code (PR6214): Perhaps instcombine should
|
|
canonicalize the former into the later?
|
|
|
|
define float @foo(float %x) nounwind {
|
|
%t = bitcast float %x to i32
|
|
%s = and i32 %t, 2147483647
|
|
%d = bitcast i32 %s to float
|
|
ret float %d
|
|
}
|
|
|
|
declare float @fabsf(float %n)
|
|
define float @bar(float %x) nounwind {
|
|
%d = call float @fabsf(float %x)
|
|
ret float %d
|
|
}
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
This IR (from PR6194):
|
|
|
|
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
|
|
target triple = "x86_64-apple-darwin10.0.0"
|
|
|
|
%0 = type { double, double }
|
|
%struct.float3 = type { float, float, float }
|
|
|
|
define void @test(%0, %struct.float3* nocapture %res) nounwind noinline ssp {
|
|
entry:
|
|
%tmp18 = extractvalue %0 %0, 0 ; <double> [#uses=1]
|
|
%tmp19 = bitcast double %tmp18 to i64 ; <i64> [#uses=1]
|
|
%tmp20 = zext i64 %tmp19 to i128 ; <i128> [#uses=1]
|
|
%tmp10 = lshr i128 %tmp20, 32 ; <i128> [#uses=1]
|
|
%tmp11 = trunc i128 %tmp10 to i32 ; <i32> [#uses=1]
|
|
%tmp12 = bitcast i32 %tmp11 to float ; <float> [#uses=1]
|
|
%tmp5 = getelementptr inbounds %struct.float3* %res, i64 0, i32 1 ; <float*> [#uses=1]
|
|
store float %tmp12, float* %tmp5
|
|
ret void
|
|
}
|
|
|
|
Compiles to:
|
|
|
|
_test: ## @test
|
|
movd %xmm0, %rax
|
|
shrq $32, %rax
|
|
movl %eax, 4(%rdi)
|
|
ret
|
|
|
|
This would be better kept in the SSE unit by treating XMM0 as a 4xfloat and
|
|
doing a shuffle from v[1] to v[0] then a float store.
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
[UNSAFE FP]
|
|
|
|
void foo(double, double, double);
|
|
void norm(double x, double y, double z) {
|
|
double scale = __builtin_sqrt(x*x + y*y + z*z);
|
|
foo(x/scale, y/scale, z/scale);
|
|
}
|
|
|
|
We currently generate an sqrtsd and 3 divsd instructions. This is bad, fp div is
|
|
slow and not pipelined. In -ffast-math mode we could compute "1.0/scale" first
|
|
and emit 3 mulsd in place of the divs. This can be done as a target-independent
|
|
transform.
|
|
|
|
If we're dealing with floats instead of doubles we could even replace the sqrtss
|
|
and inversion with an rsqrtss instruction, which computes 1/sqrt faster at the
|
|
cost of reduced accuracy.
|
|
|
|
//===---------------------------------------------------------------------===//
|