Moving potential optimizations out of PR2330 into lib/Target/README.txt.

Hopefully this isn't too much stuff to dump into this file.



git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@60285 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Eli Friedman 2008-11-30 07:36:04 +00:00
parent fc69cb475f
commit 4e16b29a6b

View File

@ -1002,3 +1002,265 @@ define i8 @addshr(i8 %x) readnone nounwind {
}
//===---------------------------------------------------------------------===//
From gcc bug 24696:
int
f (unsigned long a, unsigned long b, unsigned long c)
{
return ((a & (c - 1)) != 0) || ((b & (c - 1)) != 0);
}
int
f (unsigned long a, unsigned long b, unsigned long c)
{
return ((a & (c - 1)) != 0) | ((b & (c - 1)) != 0);
}
Both should combine to ((a|b) & (c-1)) != 0. Currently not optimized with
"clang -emit-llvm-bc | opt -std-compile-opts".
//===---------------------------------------------------------------------===//
From GCC Bug 20192:
#define PMD_MASK (~((1UL << 23) - 1))
void clear_pmd_range(unsigned long start, unsigned long end)
{
if (!(start & ~PMD_MASK) && !(end & ~PMD_MASK))
f();
}
The expression should optimize to something like
"!((start|end)&~PMD_MASK). Currently not optimized with "clang
-emit-llvm-bc | opt -std-compile-opts".
//===---------------------------------------------------------------------===//
From GCC Bug 15241:
unsigned int
foo (unsigned int a, unsigned int b)
{
if (a <= 7 && b <= 7)
baz ();
}
Should combine to "(a|b) <= 7". Currently not optimized with "clang
-emit-llvm-bc | opt -std-compile-opts".
//===---------------------------------------------------------------------===//
From GCC Bug 3756:
int
pn (int n)
{
return (n >= 0 ? 1 : -1);
}
Should combine to (n >> 31) | 1. Currently not optimized with "clang
-emit-llvm-bc | opt -std-compile-opts | llc".
//===---------------------------------------------------------------------===//
From GCC Bug 28685:
int test(int a, int b)
{
int lt = a < b;
int eq = a == b;
return (lt || eq);
}
Should combine to "a <= b". Currently not optimized with "clang
-emit-llvm-bc | opt -std-compile-opts | llc".
//===---------------------------------------------------------------------===//
void a(int variable)
{
if (variable == 4 || variable == 6)
bar();
}
This should optimize to "if ((variable | 2) == 6)". Currently not
optimized with "clang -emit-llvm-bc | opt -std-compile-opts | llc".
//===---------------------------------------------------------------------===//
unsigned int f(unsigned int i, unsigned int n) {++i; if (i == n) ++i; return
i;}
unsigned int f2(unsigned int i, unsigned int n) {++i; i += i == n; return i;}
These should combine to the same thing. Currently, the first function
produces better code on X86.
//===---------------------------------------------------------------------===//
From GCC Bug 33512:
int f(int y, int x)
{
return x & ((~x) | y);
}
Should combine to x & y. Currently not optimized with "clang
-emit-llvm-bc | opt -std-compile-opts".
//===---------------------------------------------------------------------===//
From GCC Bug 15784:
#define abs(x) x>0?x:-x
int f(int x, int y)
{
return (abs(x)) >= 0;
}
This should optimize to x == INT_MIN. (With -fwrapv.) Currently not
optimized with "clang -emit-llvm-bc | opt -std-compile-opts".
//===---------------------------------------------------------------------===//
From GCC Bug 14753:
void
rotate_cst (unsigned int a)
{
a = (a << 10) | (a >> 22);
if (a == 123)
bar ();
}
void
minus_cst (unsigned int a)
{
unsigned int tem;
tem = 20 - a;
if (tem == 5)
bar ();
}
void
mask_gt (unsigned int a)
{
/* This is equivalent to a > 15. */
if ((a & ~7) > 8)
bar ();
}
void
rshift_gt (unsigned int a)
{
/* This is equivalent to a > 23. */
if ((a >> 2) > 5)
bar ();
}
All should simplify to a single comparison. All of these are
currently not optimized with "clang -emit-llvm-bc | opt
-std-compile-opts".
//===---------------------------------------------------------------------===//
From GCC Bug 32605:
int c(int* x) {return (char*)x+2 == (char*)x;}
Should combine to 0. Currently not optimized with "clang
-emit-llvm-bc | opt -std-compile-opts" (although llc can optimize it).
//===---------------------------------------------------------------------===//
int a(unsigned char* b) {return *b > 99;}
There's an unnecessary zext in the generated code with "clang
-emit-llvm-bc | opt -std-compile-opts".
//===---------------------------------------------------------------------===//
int a(int a, int b) {return ((a|b)&1) | (b&-2);}
Should be combined to "(a&1)|b". Currently not optimized with "clang
-emit-llvm-bc | opt -std-compile-opts".
//===---------------------------------------------------------------------===//
int a(unsigned b) {return ((b << 31) | (b << 30)) >> 31;}
Should be combined to "((b >> 1) | b) & 1". Currently not optimized
with "clang -emit-llvm-bc | opt -std-compile-opts".
//===---------------------------------------------------------------------===//
unsigned a(unsigned x, unsigned y) { return x | (y & 1) | (y & 2);}
Should combine to "x | (y & 3)". Currently not optimized with "clang
-emit-llvm-bc | opt -std-compile-opts".
//===---------------------------------------------------------------------===//
unsigned a(unsigned a) {return ((a | 1) & 3) | (a & -4);}
Should combine to "a | 1". Currently not optimized with "clang
-emit-llvm-bc | opt -std-compile-opts".
//===---------------------------------------------------------------------===//
int a(int a, int b, int c) {return ((a&~b) | (~a&b));}
Should fold to xor. Currently not optimized with "clang -emit-llvm-bc
| opt -std-compile-opts".
//===---------------------------------------------------------------------===//
int a(int a, int b, int c) {return (~a & c) | ((c|a) & b);}
Should fold to "(~a & c) | (a & b)". Currently not optimized with
"clang -emit-llvm-bc | opt -std-compile-opts".
//===---------------------------------------------------------------------===//
int a(int a,int b) {return (~(a|b))|a;}
Should fold to "a|~b". Currently not optimized with "clang
-emit-llvm-bc | opt -std-compile-opts".
//===---------------------------------------------------------------------===//
int a(int a, int b) {return (a&&b) || (a&&!b);}
Should fold to "a". Currently not optimized with "clang -emit-llvm-bc
| opt -std-compile-opts".
//===---------------------------------------------------------------------===//
int a(int a, int b, int c) {return (a&&b) || (!a&&c);}
Should fold to "a ? b : c", or at least something sane. Currently not
optimized with "clang -emit-llvm-bc | opt -std-compile-opts".
//===---------------------------------------------------------------------===//
int a(int a, int b, int c) {return (a&&b) || (a&&c) || (a&&b&&c);}
Should fold to a && (b || c). Currently not optimized with "clang
-emit-llvm-bc | opt -std-compile-opts".
//===---------------------------------------------------------------------===//
int a(int x) {return x | ((x & 8) ^ 8);}
Should combine to x | 8. Currently not optimized with "clang
-emit-llvm-bc | opt -std-compile-opts".
//===---------------------------------------------------------------------===//
int a(int x) {return x ^ ((x & 8) ^ 8);}
Should also combine to x | 8. Currently not optimized with "clang
-emit-llvm-bc | opt -std-compile-opts".
//===---------------------------------------------------------------------===//
int a(int x) {return (x & 8) == 0 ? -1 : -9;}
Should combine to (x | -9) ^ 8. Currently not optimized with "clang
-emit-llvm-bc | opt -std-compile-opts".
//===---------------------------------------------------------------------===//
int a(int x) {return (x & 8) == 0 ? -9 : -1;}
Should combine to x | -9. Currently not optimized with "clang
-emit-llvm-bc | opt -std-compile-opts".
//===---------------------------------------------------------------------===//
int a(int x) {return ((x | -9) ^ 8) & x;}
Should combine to x & -9. Currently not optimized with "clang
-emit-llvm-bc | opt -std-compile-opts".
//===---------------------------------------------------------------------===//
unsigned a(unsigned a) {return a * 0x11111111 >> 28 & 1;}
Should combine to "a * 0x88888888 >> 31". Currently not optimized
with "clang -emit-llvm-bc | opt -std-compile-opts".
//===---------------------------------------------------------------------===//
unsigned a(char* x) {if ((*x & 32) == 0) return b();}
There's an unnecessary zext in the generated code with "clang
-emit-llvm-bc | opt -std-compile-opts".
//===---------------------------------------------------------------------===//
unsigned a(unsigned long long x) {return 40 * (x >> 1);}
Should combine to "20 * (((unsigned)x) & -2)". Currently not
optimized with "clang -emit-llvm-bc | opt -std-compile-opts".
//===---------------------------------------------------------------------===//