Remove BRTWOWAY*
[oota-llvm.git] / lib / Target / README.txt
1 Target Independent Opportunities:
2
3 ===-------------------------------------------------------------------------===
4
5 FreeBench/mason contains code like this:
6
7 static p_type m0u(p_type p) {
8   int m[]={0, 8, 1, 2, 16, 5, 13, 7, 14, 9, 3, 4, 11, 12, 15, 10, 17, 6};
9   p_type pu;
10   pu.a = m[p.a];
11   pu.b = m[p.b];
12   pu.c = m[p.c];
13   return pu;
14 }
15
16 We currently compile this into a memcpy from a static array into 'm', then
17 a bunch of loads from m.  It would be better to avoid the memcpy and just do
18 loads from the static array.
19
20 //===---------------------------------------------------------------------===//
21
22 Make the PPC branch selector target independant
23
24 //===---------------------------------------------------------------------===//
25
26 Get the C front-end to expand hypot(x,y) -> llvm.sqrt(x*x+y*y) when errno and
27 precision don't matter (ffastmath).  Misc/mandel will like this. :)
28
29 //===---------------------------------------------------------------------===//
30
31 Solve this DAG isel folding deficiency:
32
33 int X, Y;
34
35 void fn1(void)
36 {
37   X = X | (Y << 3);
38 }
39
40 compiles to
41
42 fn1:
43         movl Y, %eax
44         shll $3, %eax
45         orl X, %eax
46         movl %eax, X
47         ret
48
49 The problem is the store's chain operand is not the load X but rather
50 a TokenFactor of the load X and load Y, which prevents the folding.
51
52 There are two ways to fix this:
53
54 1. The dag combiner can start using alias analysis to realize that y/x
55    don't alias, making the store to X not dependent on the load from Y.
56 2. The generated isel could be made smarter in the case it can't
57    disambiguate the pointers.
58
59 Number 1 is the preferred solution.
60
61 This has been "fixed" by a TableGen hack. But that is a short term workaround
62 which will be removed once the proper fix is made.
63
64 //===---------------------------------------------------------------------===//
65
66 Turn this into a signed shift right in instcombine:
67
68 int f(unsigned x) {
69   return x >> 31 ? -1 : 0;
70 }
71
72 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=25600
73 http://gcc.gnu.org/ml/gcc-patches/2006-02/msg01492.html
74
75 //===---------------------------------------------------------------------===//
76
77 On targets with expensive 64-bit multiply, we could LSR this:
78
79 for (i = ...; ++i) {
80    x = 1ULL << i;
81
82 into:
83  long long tmp = 1;
84  for (i = ...; ++i, tmp+=tmp)
85    x = tmp;
86
87 This would be a win on ppc32, but not x86 or ppc64.
88
89 //===---------------------------------------------------------------------===//
90
91 Shrink: (setlt (loadi32 P), 0) -> (setlt (loadi8 Phi), 0)
92
93 //===---------------------------------------------------------------------===//
94
95 Reassociate should turn: X*X*X*X -> t=(X*X) (t*t) to eliminate a multiply.
96
97 //===---------------------------------------------------------------------===//
98
99 Interesting? testcase for add/shift/mul reassoc:
100
101 int bar(int x, int y) {
102   return x*x*x+y+x*x*x*x*x*y*y*y*y;
103 }
104 int foo(int z, int n) {
105   return bar(z, n) + bar(2*z, 2*n);
106 }
107
108 //===---------------------------------------------------------------------===//
109
110 These two functions should generate the same code on big-endian systems:
111
112 int g(int *j,int *l)  {  return memcmp(j,l,4);  }
113 int h(int *j, int *l) {  return *j - *l; }
114
115 this could be done in SelectionDAGISel.cpp, along with other special cases,
116 for 1,2,4,8 bytes.
117
118 //===---------------------------------------------------------------------===//
119
120 This code:
121 int rot(unsigned char b) { int a = ((b>>1) ^ (b<<7)) & 0xff; return a; }
122
123 Can be improved in two ways:
124
125 1. The instcombiner should eliminate the type conversions.
126 2. The X86 backend should turn this into a rotate by one bit.
127