test/CodeGen/Mips/dynamic-stack-realignment.ll

   1 ; RUN: llc < %s -march=mips -mcpu=mips2 | FileCheck %s \
   2 ; RUN:    --check-prefix=ALL --check-prefix=GP32
   3 ; RUN: llc < %s -march=mips -mcpu=mips32 | FileCheck %s \
   4 ; RUN:    --check-prefix=ALL --check-prefix=GP32
   5 ; RUN: llc < %s -march=mips -mcpu=mips32r6 | FileCheck %s \
   6 ; RUN:    --check-prefix=ALL --check-prefix=GP32
   7 ; RUN: llc < %s -march=mips64 -mcpu=mips3 | FileCheck %s \
   8 ; RUN:    --check-prefix=ALL --check-prefix=GP64 -check-prefix=N64
   9 ; RUN: llc < %s -march=mips64 -mcpu=mips64 | FileCheck %s \
  10 ; RUN:    --check-prefix=ALL --check-prefix=GP64 -check-prefix=N64
  11 ; RUN: llc < %s -march=mips64 -mcpu=mips64r6 | FileCheck %s \
  12 ; RUN:    --check-prefix=ALL --check-prefix=GP64 -check-prefix=N64
  13 ; RUN: llc < %s -march=mips64 -mcpu=mips3 -target-abi n32 | FileCheck %s \
  14 ; RUN:    --check-prefix=ALL --check-prefix=GP64 -check-prefix=N32
  15 ; RUN: llc < %s -march=mips64 -mcpu=mips64 -target-abi n32 | FileCheck %s \
  16 ; RUN:    --check-prefix=ALL --check-prefix=GP64 -check-prefix=N32
  17 ; RUN: llc < %s -march=mips64 -mcpu=mips64r6 -target-abi n32 | FileCheck %s \
  18 ; RUN:    --check-prefix=ALL --check-prefix=GP64 -check-prefix=N32
  19
  20 ; Check dynamic stack realignment in functions without variable-sized objects.
  21
  22 declare void @helper_01(i32, i32, i32, i32, i32*)
  23
  24 ; O32 ABI
  25 define void @func_01() {
  26 entry:
  27 ; GP32-LABEL: func_01:
  28
  29   ; prologue
  30   ; FIXME: We are currently over-allocating stack space. This particular case
  31   ;        needs a frame of up to between 16 and 512-bytes but currently
  32   ;        allocates between 1024 and 1536 bytes
  33   ; GP32:       addiu   $sp, $sp, -1024
  34   ; GP32:       sw      $ra, 1020($sp)
  35   ; GP32:       sw      $fp, 1016($sp)
  36   ;
  37   ; GP32:       move    $fp, $sp
  38   ; GP32:       addiu   $[[T0:[0-9]+|ra|gp]], $zero, -512
  39   ; GP32-NEXT:  and     $sp, $sp, $[[T0]]
  40
  41   ; body
  42   ; GP32:       addiu   $[[T1:[0-9]+]], $sp, 512
  43   ; GP32:       sw      $[[T1]], 16($sp)
  44
  45   ; epilogue
  46   ; GP32:       move    $sp, $fp
  47   ; GP32:       lw      $fp, 1016($sp)
  48   ; GP32:       lw      $ra, 1020($sp)
  49   ; GP32:       addiu   $sp, $sp, 1024
  50
  51   %a = alloca i32, align 512
  52   call void @helper_01(i32 0, i32 0, i32 0, i32 0, i32* %a)
  53   ret void
  54 }
  55
  56 declare void @helper_02(i32, i32, i32, i32,
  57                         i32, i32, i32, i32, i32*)
  58
  59 ; N32/N64 ABIs
  60 define void @func_02() {
  61 entry:
  62 ; GP64-LABEL: func_02:
  63
  64   ; prologue
  65   ; FIXME: We are currently over-allocating stack space. This particular case
  66   ;        needs a frame of up to between 16 and 512-bytes but currently
  67   ;        allocates between 1024 and 1536 bytes
  68   ; N32:        addiu   $sp, $sp, -1024
  69   ; N64:        daddiu  $sp, $sp, -1024
  70   ; GP64:       sd      $ra, 1016($sp)
  71   ; GP64:       sd      $fp, 1008($sp)
  72   ; N32:        sd      $gp, 1000($sp)
  73   ;
  74   ; GP64:       move    $fp, $sp
  75   ; N32:        addiu   $[[T0:[0-9]+|ra]], $zero, -512
  76   ; N64:        daddiu  $[[T0:[0-9]+|ra]], $zero, -512
  77   ; GP64-NEXT:  and     $sp, $sp, $[[T0]]
  78
  79   ; body
  80   ; N32:        addiu   $[[T1:[0-9]+]], $sp, 512
  81   ; N64:        daddiu  $[[T1:[0-9]+]], $sp, 512
  82   ; GP64:       sd      $[[T1]], 0($sp)
  83
  84   ; epilogue
  85   ; GP64:       move    $sp, $fp
  86   ; N32:        ld      $gp, 1000($sp)
  87   ; GP64:       ld      $fp, 1008($sp)
  88   ; GP64:       ld      $ra, 1016($sp)
  89   ; N32:        addiu   $sp, $sp, 1024
  90   ; N64:        daddiu  $sp, $sp, 1024
  91
  92   %a = alloca i32, align 512
  93   call void @helper_02(i32 0, i32 0, i32 0, i32 0,
  94                        i32 0, i32 0, i32 0, i32 0, i32* %a)
  95   ret void
  96 }
  97
  98 ; Verify that we use $fp for referencing incoming arguments.
  99
 100 declare void @helper_03(i32, i32, i32, i32, i32*, i32*)
 101
 102 ; O32 ABI
 103 define void @func_03(i32 %p0, i32 %p1, i32 %p2, i32 %p3, i32* %b) {
 104 entry:
 105 ; GP32-LABEL: func_03:
 106
 107   ; body
 108   ; FIXME: We are currently over-allocating stack space.
 109   ; GP32-DAG:   addiu   $[[T0:[0-9]+]], $sp, 512
 110   ; GP32-DAG:   sw      $[[T0]], 16($sp)
 111   ; GP32-DAG:   lw      $[[T1:[0-9]+]], 1040($fp)
 112   ; GP32-DAG:   sw      $[[T1]], 20($sp)
 113
 114   %a = alloca i32, align 512
 115   call void @helper_03(i32 0, i32 0, i32 0, i32 0, i32* %a, i32* %b)
 116   ret void
 117 }
 118
 119 declare void @helper_04(i32, i32, i32, i32,
 120                         i32, i32, i32, i32, i32*, i32*)
 121
 122 ; N32/N64 ABIs
 123 define void @func_04(i32 %p0, i32 %p1, i32 %p2, i32 %p3,
 124                      i32 %p4, i32 %p5, i32 %p6, i32 %p7,
 125                      i32* %b) {
 126 entry:
 127 ; GP64-LABEL: func_04:
 128
 129   ; body
 130   ; FIXME: We are currently over-allocating stack space.
 131   ; N32-DAG:    addiu   $[[T0:[0-9]+]], $sp, 512
 132   ; N64-DAG:    daddiu  $[[T0:[0-9]+]], $sp, 512
 133   ; GP64-DAG:   sd      $[[T0]], 0($sp)
 134   ; GP64-DAG:   ld      $[[T1:[0-9]+]], 1024($fp)
 135   ; GP64-DAG:   sd      $[[T1]], 8($sp)
 136
 137   %a = alloca i32, align 512
 138   call void @helper_04(i32 0, i32 0, i32 0, i32 0,
 139                        i32 0, i32 0, i32 0, i32 0, i32* %a, i32* %b)
 140   ret void
 141 }
 142
 143 ; Check dynamic stack realignment in functions with variable-sized objects.
 144
 145 ; O32 ABI
 146 define void @func_05(i32 %sz) {
 147 entry:
 148 ; GP32-LABEL: func_05:
 149
 150   ; prologue
 151   ; FIXME: We are currently over-allocating stack space.
 152   ; GP32:       addiu   $sp, $sp, -1024
 153   ; GP32:       sw      $fp, 1020($sp)
 154   ; GP32:       sw      $23, 1016($sp)
 155   ;
 156   ; GP32:       move    $fp, $sp
 157   ; GP32:       addiu   $[[T0:[0-9]+|gp]], $zero, -512
 158   ; GP32-NEXT:  and     $sp, $sp, $[[T0]]
 159   ; GP32-NEXT:  move    $23, $sp
 160
 161   ; body
 162   ; GP32:       addiu   $[[T1:[0-9]+]], $zero, 222
 163   ; GP32:       sw      $[[T1]], 508($23)
 164
 165   ; epilogue
 166   ; GP32:       move    $sp, $fp
 167   ; GP32:       lw      $23, 1016($sp)
 168   ; GP32:       lw      $fp, 1020($sp)
 169   ; GP32:       addiu   $sp, $sp, 1024
 170
 171   %a0 = alloca i32, i32 %sz, align 512
 172   %a1 = alloca i32, align 4
 173
 174   store volatile i32 111, i32* %a0, align 512
 175   store volatile i32 222, i32* %a1, align 4
 176
 177   ret void
 178 }
 179
 180 ; N32/N64 ABIs
 181 define void @func_06(i32 %sz) {
 182 entry:
 183 ; GP64-LABEL: func_06:
 184
 185   ; prologue
 186   ; FIXME: We are currently over-allocating stack space.
 187   ; N32:        addiu   $sp, $sp, -1024
 188   ; N64:        daddiu  $sp, $sp, -1024
 189   ; GP64:       sd      $fp, 1016($sp)
 190   ; GP64:       sd      $23, 1008($sp)
 191   ;
 192   ; GP64:       move    $fp, $sp
 193   ; GP64:       addiu   $[[T0:[0-9]+|gp]], $zero, -512
 194   ; GP64-NEXT:  and     $sp, $sp, $[[T0]]
 195   ; GP64-NEXT:  move    $23, $sp
 196
 197   ; body
 198   ; GP64:       addiu   $[[T1:[0-9]+]], $zero, 222
 199   ; GP64:       sw      $[[T1]], 508($23)
 200
 201   ; epilogue
 202   ; GP64:       move    $sp, $fp
 203   ; GP64:       ld      $23, 1008($sp)
 204   ; GP64:       ld      $fp, 1016($sp)
 205   ; N32:        addiu   $sp, $sp, 1024
 206   ; N64:        daddiu  $sp, $sp, 1024
 207
 208   %a0 = alloca i32, i32 %sz, align 512
 209   %a1 = alloca i32, align 4
 210
 211   store volatile i32 111, i32* %a0, align 512
 212   store volatile i32 222, i32* %a1, align 4
 213
 214   ret void
 215 }
 216
 217 ; Verify that we use $fp for referencing incoming arguments and $sp for
 218 ; building outbound arguments for nested function calls.
 219
 220 ; O32 ABI
 221 define void @func_07(i32 %p0, i32 %p1, i32 %p2, i32 %p3, i32 %sz) {
 222 entry:
 223 ; GP32-LABEL: func_07:
 224
 225   ; body
 226   ; FIXME: We are currently over-allocating stack space.
 227   ; GP32-DAG:       lw      $[[T0:[0-9]+]], 1040($fp)
 228   ;
 229   ; GP32-DAG:       addiu   $[[T1:[0-9]+]], $zero, 222
 230   ; GP32-DAG:       sw      $[[T1]], 508($23)
 231   ;
 232   ; GP32-DAG:       sw      $[[T2:[0-9]+]], 16($sp)
 233
 234   %a0 = alloca i32, i32 %sz, align 512
 235   %a1 = alloca i32, align 4
 236
 237   store volatile i32 111, i32* %a0, align 512
 238   store volatile i32 222, i32* %a1, align 4
 239
 240   call void @helper_01(i32 0, i32 0, i32 0, i32 0, i32* %a1)
 241
 242   ret void
 243 }
 244
 245 ; N32/N64 ABIs
 246 define void @func_08(i32 %p0, i32 %p1, i32 %p2, i32 %p3,
 247                      i32 %p4, i32 %p5, i32 %p6, i32 %p7,
 248                      i32 %sz) {
 249 entry:
 250 ; GP64-LABEL: func_08:
 251
 252   ; body
 253   ; FIXME: We are currently over-allocating stack space.
 254   ; N32-DAG:        lw      $[[T0:[0-9]+]], 1028($fp)
 255   ; N64-DAG:        lwu     $[[T0:[0-9]+]], 1028($fp)
 256   ;
 257   ; GP64-DAG:       addiu   $[[T1:[0-9]+]], $zero, 222
 258   ; GP64-DAG:       sw      $[[T1]], 508($23)
 259   ;
 260   ; GP64-DAG:       sd      $[[T2:[0-9]+]], 0($sp)
 261
 262   %a0 = alloca i32, i32 %sz, align 512
 263   %a1 = alloca i32, align 4
 264
 265   store volatile i32 111, i32* %a0, align 512
 266   store volatile i32 222, i32* %a1, align 4
 267
 268   call void @helper_02(i32 0, i32 0, i32 0, i32 0,
 269                        i32 0, i32 0, i32 0, i32 0, i32* %a1)
 270   ret void
 271 }
 272
 273 ; Check that we do not perform dynamic stack realignment in the presence of
 274 ; the "no-realign-stack" function attribute.
 275 define void @func_09() "no-realign-stack" {
 276 entry:
 277 ; ALL-LABEL: func_09:
 278
 279   ; ALL-NOT:  and     $sp, $sp, $[[T0:[0-9]+|ra|gp]]
 280
 281   %a = alloca i32, align 512
 282   call void @helper_01(i32 0, i32 0, i32 0, i32 0, i32* %a)
 283   ret void
 284 }
 285
 286 define void @func_10(i32 %sz) "no-realign-stack" {
 287 entry:
 288 ; ALL-LABEL: func_10:
 289
 290   ; ALL-NOT:  and     $sp, $sp, $[[T0:[0-9]+|ra|gp]]
 291
 292   %a0 = alloca i32, i32 %sz, align 512
 293   %a1 = alloca i32, align 4
 294
 295   store volatile i32 111, i32* %a0, align 512
 296   store volatile i32 222, i32* %a1, align 4
 297
 298   ret void
 299 }