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 COUNT or BRANCH ON INDEX families of instruction.
  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 combined COMPARE AND BRANCH instructions.  Using them
  60 would require a change to the way we handle out-of-range branches.
  61 At the moment, we start with 32-bit forms like BRCL and shorten them
  62 to forms like BRC where possible, but COMPARE AND BRANCH does not have
  63 a 32-bit form.
  64
  65 --
  66
  67 We should probably model just CC, not the PSW as a whole.  Strictly
  68 speaking, every instruction changes the PSW since the PSW contains the
  69 current instruction address.
  70
  71 --
  72
  73 We don't use the condition code results of anything except comparisons.
  74
  75 Implementing this may need something more finely grained than the z_cmp
  76 and z_ucmp that we have now.  It might (or might not) also be useful to
  77 have a mask of "don't care" values in conditional branches.  For example,
  78 integer comparisons never set CC to 3, so the bottom bit of the CC mask
  79 isn't particularly relevant.  JNLH and JE are equally good for testing
  80 equality after an integer comparison, etc.
  81
  82 --
  83
  84 We don't use the LOAD AND TEST or TEST DATA CLASS instructions.
  85
  86 --
  87
  88 We could use the generic floating-point forms of LOAD COMPLEMENT,
  89 LOAD NEGATIVE and LOAD POSITIVE in cases where we don't need the
  90 condition codes.  For example, we could use LCDFR instead of LCDBR.
  91
  92 --
  93
  94 We don't optimize block memory operations.
  95
  96 It's definitely worth using things like MVC, CLC, NC, XC and OC with
  97 constant lengths.  MVCIN may be worthwhile too.
  98
  99 We should probably implement things like memcpy using MVC with EXECUTE.
 100 Likewise memcmp and CLC.  MVCLE and CLCLE could be useful too.
 101
 102 --
 103
 104 We don't optimize string operations.
 105
 106 MVST, CLST, SRST and CUSE could be useful here.  Some of the TRANSLATE
 107 family might be too, although they are probably more difficult to exploit.
 108
 109 --
 110
 111 We don't take full advantage of builtins like fabsl because the calling
 112 conventions require f128s to be returned by invisible reference.
 113
 114 --
 115
 116 ADD LOGICAL WITH SIGNED IMMEDIATE could be useful when we need to
 117 produce a carry.  SUBTRACT LOGICAL IMMEDIATE could be useful when we
 118 need to produce a borrow.  (Note that there are no memory forms of
 119 ADD LOGICAL WITH CARRY and SUBTRACT LOGICAL WITH BORROW, so the high
 120 part of 128-bit memory operations would probably need to be done
 121 via a register.)
 122
 123 --
 124
 125 We don't use the halfword forms of LOAD REVERSED and STORE REVERSED
 126 (LRVH and STRVH).
 127
 128 --
 129
 130 We could take advantage of the various ... UNDER MASK instructions,
 131 such as ICM and STCM.
 132
 133 --
 134
 135 We could make more use of the ROTATE AND ... SELECTED BITS instructions.
 136 At the moment we only use RISBG, and only then for subword atomic operations.
 137
 138 --
 139
 140 DAGCombiner can detect integer absolute, but there's not yet an associated
 141 ISD opcode.  We could add one and implement it using LOAD POSITIVE.
 142 Negated absolutes could use LOAD NEGATIVE.
 143
 144 --
 145
 146 DAGCombiner doesn't yet fold truncations of extended loads.  Functions like:
 147
 148     unsigned long f (unsigned long x, unsigned short *y)
 149     {
 150       return (x << 32) | *y;
 151     }
 152
 153 therefore end up as:
 154
 155         sllg    %r2, %r2, 32
 156         llgh    %r0, 0(%r3)
 157         lr      %r2, %r0
 158         br      %r14
 159
 160 but truncating the load would give:
 161
 162         sllg    %r2, %r2, 32
 163         lh      %r2, 0(%r3)
 164         br      %r14
 165
 166 --
 167
 168 Functions like:
 169
 170 define i64 @f1(i64 %a) {
 171   %and = and i64 %a, 1
 172   ret i64 %and
 173 }
 174
 175 ought to be implemented as:
 176
 177         lhi     %r0, 1
 178         ngr     %r2, %r0
 179         br      %r14
 180
 181 but two-address optimisations reverse the order of the AND and force:
 182
 183         lhi     %r0, 1
 184         ngr     %r0, %r2
 185         lgr     %r2, %r0
 186         br      %r14
 187
 188 CodeGen/SystemZ/and-04.ll has several examples of this.
 189
 190 --
 191
 192 Out-of-range displacements are usually handled by loading the full
 193 address into a register.  In many cases it would be better to create
 194 an anchor point instead.  E.g. for:
 195
 196 define void @f4a(i128 *%aptr, i64 %base) {
 197   %addr = add i64 %base, 524288
 198   %bptr = inttoptr i64 %addr to i128 *
 199   %a = load volatile i128 *%aptr
 200   %b = load i128 *%bptr
 201   %add = add i128 %a, %b
 202   store i128 %add, i128 *%aptr
 203   ret void
 204 }
 205
 206 (from CodeGen/SystemZ/int-add-08.ll) we load %base+524288 and %base+524296
 207 into separate registers, rather than using %base+524288 as a base for both.
 208
 209 --
 210
 211 Dynamic stack allocations round the size to 8 bytes and then allocate
 212 that rounded amount.  It would be simpler to subtract the unrounded
 213 size from the copy of the stack pointer and then align the result.
 214 See CodeGen/SystemZ/alloca-01.ll for an example.
 215
 216 --
 217
 218 Atomic loads and stores use the default compare-and-swap based implementation.
 219 This is much too conservative in practice, since the architecture guarantees
 220 that 1-, 2-, 4- and 8-byte loads and stores to aligned addresses are
 221 inherently atomic.
 222
 223 --
 224
 225 If needed, we can support 16-byte atomics using LPQ, STPQ and CSDG.
 226
 227 --
 228
 229 We might want to model all access registers and use them to spill
 230 32-bit values.