lib/Target/SystemZ/README.txt

   1 //===---------------------------------------------------------------------===//
   2 // Random notes about and ideas for the SystemZ backend.
   3 //===---------------------------------------------------------------------===//
   4
   5 The initial backend is deliberately restricted to z10.  We should add support
   6 for later architectures at some point.
   7
   8 --
   9
  10 SystemZDAGToDAGISel::SelectInlineAsmMemoryOperand() is passed "m" for all
  11 inline asm memory constraints; it doesn't get to see the original constraint.
  12 This means that it must conservatively treat all inline asm constraints
  13 as the most restricted type, "R".
  14
  15 --
  16
  17 If an inline asm ties an i32 "r" result to an i64 input, the input
  18 will be treated as an i32, leaving the upper bits uninitialised.
  19 For example:
  20
  21 define void @f4(i32 *%dst) {
  22   %val = call i32 asm "blah $0", "=r,0" (i64 103)
  23   store i32 %val, i32 *%dst
  24   ret void
  25 }
  26
  27 from CodeGen/SystemZ/asm-09.ll will use LHI rather than LGHI.
  28 to load 103.  This seems to be a general target-independent problem.
  29
  30 --
  31
  32 The tuning of the choice between LOAD ADDRESS (LA) and addition in
  33 SystemZISelDAGToDAG.cpp is suspect.  It should be tweaked based on
  34 performance measurements.
  35
  36 --
  37
  38 We don't support tail calls at present.
  39
  40 --
  41
  42 We don't support prefetching yet.
  43
  44 --
  45
  46 There is no scheduling support.
  47
  48 --
  49
  50 We don't use the BRANCH ON INDEX instructions.
  51
  52 --
  53
  54 We might want to use BRANCH ON CONDITION for conditional indirect calls
  55 and conditional returns.
  56
  57 --
  58
  59 We don't use the TEST DATA CLASS instructions.
  60
  61 --
  62
  63 We could use the generic floating-point forms of LOAD COMPLEMENT,
  64 LOAD NEGATIVE and LOAD POSITIVE in cases where we don't need the
  65 condition codes.  For example, we could use LCDFR instead of LCDBR.
  66
  67 --
  68
  69 We don't optimize block memory operations, except using single MVCs
  70 for memcpy.
  71
  72 It's definitely worth using things like CLC, NC, XC and OC with
  73 constant lengths.  MVCIN may be worthwhile too.
  74
  75 We should probably implement things like memcpy using MVC with EXECUTE.
  76 Likewise memcmp and CLC.  MVCLE and CLCLE could be useful too.
  77
  78 --
  79
  80 We don't optimize string operations.
  81
  82 MVST, CLST, SRST and CUSE could be useful here.  Some of the TRANSLATE
  83 family might be too, although they are probably more difficult to exploit.
  84
  85 --
  86
  87 We don't take full advantage of builtins like fabsl because the calling
  88 conventions require f128s to be returned by invisible reference.
  89
  90 --
  91
  92 ADD LOGICAL WITH SIGNED IMMEDIATE could be useful when we need to
  93 produce a carry.  SUBTRACT LOGICAL IMMEDIATE could be useful when we
  94 need to produce a borrow.  (Note that there are no memory forms of
  95 ADD LOGICAL WITH CARRY and SUBTRACT LOGICAL WITH BORROW, so the high
  96 part of 128-bit memory operations would probably need to be done
  97 via a register.)
  98
  99 --
 100
 101 We don't use the halfword forms of LOAD REVERSED and STORE REVERSED
 102 (LRVH and STRVH).
 103
 104 --
 105
 106 We could take advantage of the various ... UNDER MASK instructions,
 107 such as ICM and STCM.
 108
 109 --
 110
 111 DAGCombiner can detect integer absolute, but there's not yet an associated
 112 ISD opcode.  We could add one and implement it using LOAD POSITIVE.
 113 Negated absolutes could use LOAD NEGATIVE.
 114
 115 --
 116
 117 DAGCombiner doesn't yet fold truncations of extended loads.  Functions like:
 118
 119     unsigned long f (unsigned long x, unsigned short *y)
 120     {
 121       return (x << 32) | *y;
 122     }
 123
 124 therefore end up as:
 125
 126         sllg    %r2, %r2, 32
 127         llgh    %r0, 0(%r3)
 128         lr      %r2, %r0
 129         br      %r14
 130
 131 but truncating the load would give:
 132
 133         sllg    %r2, %r2, 32
 134         lh      %r2, 0(%r3)
 135         br      %r14
 136
 137 --
 138
 139 Functions like:
 140
 141 define i64 @f1(i64 %a) {
 142   %and = and i64 %a, 1
 143   ret i64 %and
 144 }
 145
 146 ought to be implemented as:
 147
 148         lhi     %r0, 1
 149         ngr     %r2, %r0
 150         br      %r14
 151
 152 but two-address optimisations reverse the order of the AND and force:
 153
 154         lhi     %r0, 1
 155         ngr     %r0, %r2
 156         lgr     %r2, %r0
 157         br      %r14
 158
 159 CodeGen/SystemZ/and-04.ll has several examples of this.
 160
 161 --
 162
 163 Out-of-range displacements are usually handled by loading the full
 164 address into a register.  In many cases it would be better to create
 165 an anchor point instead.  E.g. for:
 166
 167 define void @f4a(i128 *%aptr, i64 %base) {
 168   %addr = add i64 %base, 524288
 169   %bptr = inttoptr i64 %addr to i128 *
 170   %a = load volatile i128 *%aptr
 171   %b = load i128 *%bptr
 172   %add = add i128 %a, %b
 173   store i128 %add, i128 *%aptr
 174   ret void
 175 }
 176
 177 (from CodeGen/SystemZ/int-add-08.ll) we load %base+524288 and %base+524296
 178 into separate registers, rather than using %base+524288 as a base for both.
 179
 180 --
 181
 182 Dynamic stack allocations round the size to 8 bytes and then allocate
 183 that rounded amount.  It would be simpler to subtract the unrounded
 184 size from the copy of the stack pointer and then align the result.
 185 See CodeGen/SystemZ/alloca-01.ll for an example.
 186
 187 --
 188
 189 Atomic loads and stores use the default compare-and-swap based implementation.
 190 This is much too conservative in practice, since the architecture guarantees
 191 that 1-, 2-, 4- and 8-byte loads and stores to aligned addresses are
 192 inherently atomic.
 193
 194 --
 195
 196 If needed, we can support 16-byte atomics using LPQ, STPQ and CSDG.
 197
 198 --
 199
 200 We might want to model all access registers and use them to spill
 201 32-bit values.