2006-02-03 06:21:43 +00:00
|
|
|
Target Independent Opportunities:
|
|
|
|
|
|
|
|
===-------------------------------------------------------------------------===
|
|
|
|
|
|
|
|
FreeBench/mason contains code like this:
|
|
|
|
|
|
|
|
static p_type m0u(p_type p) {
|
|
|
|
int m[]={0, 8, 1, 2, 16, 5, 13, 7, 14, 9, 3, 4, 11, 12, 15, 10, 17, 6};
|
|
|
|
p_type pu;
|
|
|
|
pu.a = m[p.a];
|
|
|
|
pu.b = m[p.b];
|
|
|
|
pu.c = m[p.c];
|
|
|
|
return pu;
|
|
|
|
}
|
|
|
|
|
|
|
|
We currently compile this into a memcpy from a static array into 'm', then
|
|
|
|
a bunch of loads from m. It would be better to avoid the memcpy and just do
|
|
|
|
loads from the static array.
|
|
|
|
|
|
|
|
===-------------------------------------------------------------------------===
|
|
|
|
|
|
|
|
Get the C front-end to expand hypot(x,y) -> llvm.sqrt(x*x+y*y) when errno and
|
|
|
|
precision don't matter (ffastmath). Misc/mandel will like this. :)
|
|
|
|
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
Solve this DAG isel folding deficiency:
|
|
|
|
|
|
|
|
int X, Y;
|
|
|
|
|
|
|
|
void fn1(void)
|
|
|
|
{
|
|
|
|
X = X | (Y << 3);
|
|
|
|
}
|
|
|
|
|
|
|
|
compiles to
|
|
|
|
|
|
|
|
fn1:
|
|
|
|
movl Y, %eax
|
|
|
|
shll $3, %eax
|
|
|
|
orl X, %eax
|
|
|
|
movl %eax, X
|
|
|
|
ret
|
|
|
|
|
|
|
|
The problem is the store's chain operand is not the load X but rather
|
|
|
|
a TokenFactor of the load X and load Y, which prevents the folding.
|
|
|
|
|
|
|
|
There are two ways to fix this:
|
|
|
|
|
|
|
|
1. The dag combiner can start using alias analysis to realize that y/x
|
|
|
|
don't alias, making the store to X not dependent on the load from Y.
|
|
|
|
2. The generated isel could be made smarter in the case it can't
|
|
|
|
disambiguate the pointers.
|
|
|
|
|
|
|
|
Number 1 is the preferred solution.
|
|
|
|
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
|
2006-02-15 19:52:06 +00:00
|
|
|
DAG combine this into mul A, 8:
|
|
|
|
|
|
|
|
int %test(int %A) {
|
|
|
|
%B = mul int %A, 8 ;; shift
|
|
|
|
%C = add int %B, 7 ;; dead, no demanded bits.
|
|
|
|
%D = and int %C, -8 ;; dead once add is gone.
|
|
|
|
ret int %D
|
|
|
|
}
|
|
|
|
|
|
|
|
This sort of thing occurs in the alloca lowering code and other places that
|
|
|
|
are generating alignment of an already aligned value.
|
|
|
|
|
2006-02-21 18:29:44 +00:00
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
Turn this into a signed shift right in instcombine:
|
|
|
|
|
|
|
|
int f(unsigned x) {
|
|
|
|
return x >> 31 ? -1 : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
http://gcc.gnu.org/bugzilla/show_bug.cgi?id=25600
|
|
|
|
http://gcc.gnu.org/ml/gcc-patches/2006-02/msg01492.html
|
|
|
|
|
2006-03-02 22:34:38 +00:00
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
We should reassociate:
|
|
|
|
int f(int a, int b){ return a * a + 2 * a * b + b * b; }
|
|
|
|
into:
|
|
|
|
int f(int a, int b) { return a * (a + 2 * b) + b * b; }
|
|
|
|
to eliminate a multiply.
|
2006-03-04 01:19:34 +00:00
|
|
|
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
On targets with expensive 64-bit multiply, we could LSR this:
|
|
|
|
|
|
|
|
for (i = ...; ++i) {
|
|
|
|
x = 1ULL << i;
|
|
|
|
|
|
|
|
into:
|
|
|
|
long long tmp = 1;
|
|
|
|
for (i = ...; ++i, tmp+=tmp)
|
|
|
|
x = tmp;
|
|
|
|
|
|
|
|
This would be a win on ppc32, but not x86 or ppc64.
|
|
|
|
|
2006-03-04 08:44:51 +00:00
|
|
|
//===---------------------------------------------------------------------===//
|
2006-03-05 20:00:08 +00:00
|
|
|
|
|
|
|
Shrink: (setlt (loadi32 P), 0) -> (setlt (loadi8 Phi), 0)
|
|
|
|
|
|
|
|
//===---------------------------------------------------------------------===//
|
2006-03-07 02:46:26 +00:00
|
|
|
|
|
|
|
Reassociate is missing this:
|
|
|
|
|
|
|
|
int test(int X, int Y) {
|
|
|
|
return (X+X+Y+Y); // (X+Y) << 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
it needs to turn the shifts into multiplies to get it.
|
|
|
|
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
|
2006-03-11 20:17:08 +00:00
|
|
|
Reassociate should turn: X*X*X*X -> t=(X*X) (t*t) to eliminate a multiply.
|
|
|
|
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
|
2006-03-11 20:20:40 +00:00
|
|
|
Interesting? testcase for add/shift/mul reassoc:
|
|
|
|
|
|
|
|
int bar(int x, int y) {
|
|
|
|
return x*x*x+y+x*x*x*x*x*y*y*y*y;
|
|
|
|
}
|
|
|
|
int foo(int z, int n) {
|
|
|
|
return bar(z, n) + bar(2*z, 2*n);
|
|
|
|
}
|
|
|
|
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
|
2006-03-09 20:13:21 +00:00
|
|
|
These two functions should generate the same code on big-endian systems:
|
|
|
|
|
|
|
|
int g(int *j,int *l) { return memcmp(j,l,4); }
|
|
|
|
int h(int *j, int *l) { return *j - *l; }
|
|
|
|
|
|
|
|
this could be done in SelectionDAGISel.cpp, along with other special cases,
|
|
|
|
for 1,2,4,8 bytes.
|
|
|
|
|
|
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
|