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 Get the C front-end to expand hypot(x,y) -> llvm.sqrt(x*x+y*y) when errno and
  23 precision don't matter (ffastmath).  Misc/mandel will like this. :)
  24
  25 //===---------------------------------------------------------------------===//
  26
  27 Solve this DAG isel folding deficiency:
  28
  29 int X, Y;
  30
  31 void fn1(void)
  32 {
  33   X = X | (Y << 3);
  34 }
  35
  36 compiles to
  37
  38 fn1:
  39         movl Y, %eax
  40         shll $3, %eax
  41         orl X, %eax
  42         movl %eax, X
  43         ret
  44
  45 The problem is the store's chain operand is not the load X but rather
  46 a TokenFactor of the load X and load Y, which prevents the folding.
  47
  48 There are two ways to fix this:
  49
  50 1. The dag combiner can start using alias analysis to realize that y/x
  51    don't alias, making the store to X not dependent on the load from Y.
  52 2. The generated isel could be made smarter in the case it can't
  53    disambiguate the pointers.
  54
  55 Number 1 is the preferred solution.
  56
  57 //===---------------------------------------------------------------------===//
  58
  59 DAG combine this into mul A, 8:
  60
  61 int %test(int %A) {
  62   %B = mul int %A, 8  ;; shift
  63   %C = add int %B, 7  ;; dead, no demanded bits.
  64   %D = and int %C, -8 ;; dead once add is gone.
  65   ret int %D
  66 }
  67
  68 This sort of thing occurs in the alloca lowering code and other places that
  69 are generating alignment of an already aligned value.
  70
  71 //===---------------------------------------------------------------------===//
  72
  73 Turn this into a signed shift right in instcombine:
  74
  75 int f(unsigned x) {
  76   return x >> 31 ? -1 : 0;
  77 }
  78
  79 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=25600
  80 http://gcc.gnu.org/ml/gcc-patches/2006-02/msg01492.html
  81
  82 //===---------------------------------------------------------------------===//
  83
  84 We should reassociate:
  85 int f(int a, int b){ return a * a + 2 * a * b + b * b; }
  86 into:
  87 int f(int a, int b) { return a * (a + 2 * b) + b * b; }
  88 to eliminate a multiply.
  89
  90 //===---------------------------------------------------------------------===//
  91
  92 On targets with expensive 64-bit multiply, we could LSR this:
  93
  94 for (i = ...; ++i) {
  95    x = 1ULL << i;
  96
  97 into:
  98  long long tmp = 1;
  99  for (i = ...; ++i, tmp+=tmp)
 100    x = tmp;
 101
 102 This would be a win on ppc32, but not x86 or ppc64.
 103
 104 //===---------------------------------------------------------------------===//
 105
 106 Shrink: (setlt (loadi32 P), 0) -> (setlt (loadi8 Phi), 0)
 107
 108 //===---------------------------------------------------------------------===//
 109
 110 Reassociate is missing this:
 111
 112 int test(int X, int Y) {
 113  return (X+X+Y+Y);  // (X+Y) << 1;
 114 }
 115
 116 it needs to turn the shifts into multiplies to get it.
 117
 118 //===---------------------------------------------------------------------===//
 119
 120 Reassociate should turn: X*X*X*X -> t=(X*X) (t*t) to eliminate a multiply.
 121
 122 //===---------------------------------------------------------------------===//
 123
 124 Interesting? testcase for add/shift/mul reassoc:
 125
 126 int bar(int x, int y) {
 127   return x*x*x+y+x*x*x*x*x*y*y*y*y;
 128 }
 129 int foo(int z, int n) {
 130   return bar(z, n) + bar(2*z, 2*n);
 131 }
 132
 133 //===---------------------------------------------------------------------===//
 134
 135 These two functions should generate the same code on big-endian systems:
 136
 137 int g(int *j,int *l)  {  return memcmp(j,l,4);  }
 138 int h(int *j, int *l) {  return *j - *l; }
 139
 140 this could be done in SelectionDAGISel.cpp, along with other special cases,
 141 for 1,2,4,8 bytes.
 142
 143 //===---------------------------------------------------------------------===//
 144