test/CodeGen/X86/peephole-na-phys-copy-folding.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
   2 ; RUN: llc -mtriple=i386-linux-gnu %s -o - | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK32
   3 ; RUN: llc -mtriple=x86_64-linux-gnu -mattr=+sahf %s -o - | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK64
   4
   5 ; TODO: Reenable verify-machineinstrs once the if (!AXDead) // FIXME in
   6 ; X86InstrInfo::copyPhysReg() is resolved.
   7
   8 ; The peephole optimizer can elide some physical register copies such as
   9 ; EFLAGS. Make sure the flags are used directly, instead of needlessly using
  10 ; lahf, when possible.
  11
  12 @L = external global i32
  13 @M = external global i8
  14
  15 declare i32 @bar(i64)
  16
  17 define i1 @plus_one() nounwind {
  18 ; CHECK32-LABEL: plus_one:
  19 ; CHECK32:       # BB#0: # %entry
  20 ; CHECK32-NEXT:    movb M, %al
  21 ; CHECK32-NEXT:    incl L
  22 ; CHECK32-NEXT:    jne .LBB0_2
  23 ; CHECK32-NEXT:  # BB#1: # %entry
  24 ; CHECK32-NEXT:    andb $8, %al
  25 ; CHECK32-NEXT:    je .LBB0_2
  26 ; CHECK32-NEXT:  # BB#3: # %exit2
  27 ; CHECK32-NEXT:    xorl %eax, %eax
  28 ; CHECK32-NEXT:    retl
  29 ; CHECK32-NEXT:  .LBB0_2: # %exit
  30 ; CHECK32-NEXT:    movb $1, %al
  31 ; CHECK32-NEXT:    retl
  32 ;
  33 ; CHECK64-LABEL: plus_one:
  34 ; CHECK64:       # BB#0: # %entry
  35 ; CHECK64-NEXT:    movb {{.*}}(%rip), %al
  36 ; CHECK64-NEXT:    incl {{.*}}(%rip)
  37 ; CHECK64-NEXT:    jne .LBB0_2
  38 ; CHECK64-NEXT:  # BB#1: # %entry
  39 ; CHECK64-NEXT:    andb $8, %al
  40 ; CHECK64-NEXT:    je .LBB0_2
  41 ; CHECK64-NEXT:  # BB#3: # %exit2
  42 ; CHECK64-NEXT:    xorl %eax, %eax
  43 ; CHECK64-NEXT:    retq
  44 ; CHECK64-NEXT:  .LBB0_2: # %exit
  45 ; CHECK64-NEXT:    movb $1, %al
  46 ; CHECK64-NEXT:    retq
  47 entry:
  48   %loaded_L = load i32, i32* @L
  49   %val = add nsw i32 %loaded_L, 1 ; N.B. will emit inc.
  50   store i32 %val, i32* @L
  51   %loaded_M = load i8, i8* @M
  52   %masked = and i8 %loaded_M, 8
  53   %M_is_true = icmp ne i8 %masked, 0
  54   %L_is_false = icmp eq i32 %val, 0
  55   %cond = and i1 %L_is_false, %M_is_true
  56   br i1 %cond, label %exit2, label %exit
  57
  58 exit:
  59   ret i1 true
  60
  61 exit2:
  62   ret i1 false
  63 }
  64
  65 define i1 @plus_forty_two() nounwind {
  66 ; CHECK32-LABEL: plus_forty_two:
  67 ; CHECK32:       # BB#0: # %entry
  68 ; CHECK32-NEXT:    movb M, %al
  69 ; CHECK32-NEXT:    addl $42, L
  70 ; CHECK32-NEXT:    jne .LBB1_2
  71 ; CHECK32-NEXT:  # BB#1: # %entry
  72 ; CHECK32-NEXT:    andb $8, %al
  73 ; CHECK32-NEXT:    je .LBB1_2
  74 ; CHECK32-NEXT:  # BB#3: # %exit2
  75 ; CHECK32-NEXT:    xorl %eax, %eax
  76 ; CHECK32-NEXT:    retl
  77 ; CHECK32-NEXT:  .LBB1_2: # %exit
  78 ; CHECK32-NEXT:    movb $1, %al
  79 ; CHECK32-NEXT:    retl
  80 ;
  81 ; CHECK64-LABEL: plus_forty_two:
  82 ; CHECK64:       # BB#0: # %entry
  83 ; CHECK64-NEXT:    movb {{.*}}(%rip), %al
  84 ; CHECK64-NEXT:    addl $42, {{.*}}(%rip)
  85 ; CHECK64-NEXT:    jne .LBB1_2
  86 ; CHECK64-NEXT:  # BB#1: # %entry
  87 ; CHECK64-NEXT:    andb $8, %al
  88 ; CHECK64-NEXT:    je .LBB1_2
  89 ; CHECK64-NEXT:  # BB#3: # %exit2
  90 ; CHECK64-NEXT:    xorl %eax, %eax
  91 ; CHECK64-NEXT:    retq
  92 ; CHECK64-NEXT:  .LBB1_2: # %exit
  93 ; CHECK64-NEXT:    movb $1, %al
  94 ; CHECK64-NEXT:    retq
  95 entry:
  96   %loaded_L = load i32, i32* @L
  97   %val = add nsw i32 %loaded_L, 42 ; N.B. won't emit inc.
  98   store i32 %val, i32* @L
  99   %loaded_M = load i8, i8* @M
 100   %masked = and i8 %loaded_M, 8
 101   %M_is_true = icmp ne i8 %masked, 0
 102   %L_is_false = icmp eq i32 %val, 0
 103   %cond = and i1 %L_is_false, %M_is_true
 104   br i1 %cond, label %exit2, label %exit
 105
 106 exit:
 107   ret i1 true
 108
 109 exit2:
 110   ret i1 false
 111 }
 112
 113 define i1 @minus_one() nounwind {
 114 ; CHECK32-LABEL: minus_one:
 115 ; CHECK32:       # BB#0: # %entry
 116 ; CHECK32-NEXT:    movb M, %al
 117 ; CHECK32-NEXT:    decl L
 118 ; CHECK32-NEXT:    jne .LBB2_2
 119 ; CHECK32-NEXT:  # BB#1: # %entry
 120 ; CHECK32-NEXT:    andb $8, %al
 121 ; CHECK32-NEXT:    je .LBB2_2
 122 ; CHECK32-NEXT:  # BB#3: # %exit2
 123 ; CHECK32-NEXT:    xorl %eax, %eax
 124 ; CHECK32-NEXT:    retl
 125 ; CHECK32-NEXT:  .LBB2_2: # %exit
 126 ; CHECK32-NEXT:    movb $1, %al
 127 ; CHECK32-NEXT:    retl
 128 ;
 129 ; CHECK64-LABEL: minus_one:
 130 ; CHECK64:       # BB#0: # %entry
 131 ; CHECK64-NEXT:    movb {{.*}}(%rip), %al
 132 ; CHECK64-NEXT:    decl {{.*}}(%rip)
 133 ; CHECK64-NEXT:    jne .LBB2_2
 134 ; CHECK64-NEXT:  # BB#1: # %entry
 135 ; CHECK64-NEXT:    andb $8, %al
 136 ; CHECK64-NEXT:    je .LBB2_2
 137 ; CHECK64-NEXT:  # BB#3: # %exit2
 138 ; CHECK64-NEXT:    xorl %eax, %eax
 139 ; CHECK64-NEXT:    retq
 140 ; CHECK64-NEXT:  .LBB2_2: # %exit
 141 ; CHECK64-NEXT:    movb $1, %al
 142 ; CHECK64-NEXT:    retq
 143 entry:
 144   %loaded_L = load i32, i32* @L
 145   %val = add nsw i32 %loaded_L, -1 ; N.B. will emit dec.
 146   store i32 %val, i32* @L
 147   %loaded_M = load i8, i8* @M
 148   %masked = and i8 %loaded_M, 8
 149   %M_is_true = icmp ne i8 %masked, 0
 150   %L_is_false = icmp eq i32 %val, 0
 151   %cond = and i1 %L_is_false, %M_is_true
 152   br i1 %cond, label %exit2, label %exit
 153
 154 exit:
 155   ret i1 true
 156
 157 exit2:
 158   ret i1 false
 159 }
 160
 161 define i1 @minus_forty_two() nounwind {
 162 ; CHECK32-LABEL: minus_forty_two:
 163 ; CHECK32:       # BB#0: # %entry
 164 ; CHECK32-NEXT:    movb M, %al
 165 ; CHECK32-NEXT:    addl $-42, L
 166 ; CHECK32-NEXT:    jne .LBB3_2
 167 ; CHECK32-NEXT:  # BB#1: # %entry
 168 ; CHECK32-NEXT:    andb $8, %al
 169 ; CHECK32-NEXT:    je .LBB3_2
 170 ; CHECK32-NEXT:  # BB#3: # %exit2
 171 ; CHECK32-NEXT:    xorl %eax, %eax
 172 ; CHECK32-NEXT:    retl
 173 ; CHECK32-NEXT:  .LBB3_2: # %exit
 174 ; CHECK32-NEXT:    movb $1, %al
 175 ; CHECK32-NEXT:    retl
 176 ;
 177 ; CHECK64-LABEL: minus_forty_two:
 178 ; CHECK64:       # BB#0: # %entry
 179 ; CHECK64-NEXT:    movb {{.*}}(%rip), %al
 180 ; CHECK64-NEXT:    addl $-42, {{.*}}(%rip)
 181 ; CHECK64-NEXT:    jne .LBB3_2
 182 ; CHECK64-NEXT:  # BB#1: # %entry
 183 ; CHECK64-NEXT:    andb $8, %al
 184 ; CHECK64-NEXT:    je .LBB3_2
 185 ; CHECK64-NEXT:  # BB#3: # %exit2
 186 ; CHECK64-NEXT:    xorl %eax, %eax
 187 ; CHECK64-NEXT:    retq
 188 ; CHECK64-NEXT:  .LBB3_2: # %exit
 189 ; CHECK64-NEXT:    movb $1, %al
 190 ; CHECK64-NEXT:    retq
 191 entry:
 192   %loaded_L = load i32, i32* @L
 193   %val = add nsw i32 %loaded_L, -42 ; N.B. won't emit dec.
 194   store i32 %val, i32* @L
 195   %loaded_M = load i8, i8* @M
 196   %masked = and i8 %loaded_M, 8
 197   %M_is_true = icmp ne i8 %masked, 0
 198   %L_is_false = icmp eq i32 %val, 0
 199   %cond = and i1 %L_is_false, %M_is_true
 200   br i1 %cond, label %exit2, label %exit
 201
 202 exit:
 203   ret i1 true
 204
 205 exit2:
 206   ret i1 false
 207 }
 208
 209 define i64 @test_intervening_call(i64* %foo, i64 %bar, i64 %baz) nounwind {
 210 ; CHECK32-LABEL: test_intervening_call:
 211 ; CHECK32:       # BB#0: # %entry
 212 ; CHECK32-NEXT:    pushl %ebp
 213 ; CHECK32-NEXT:    movl %esp, %ebp
 214 ; CHECK32-NEXT:    pushl %ebx
 215 ; CHECK32-NEXT:    pushl %esi
 216 ; CHECK32-NEXT:    movl 12(%ebp), %eax
 217 ; CHECK32-NEXT:    movl 16(%ebp), %edx
 218 ; CHECK32-NEXT:    movl 20(%ebp), %ebx
 219 ; CHECK32-NEXT:    movl 24(%ebp), %ecx
 220 ; CHECK32-NEXT:    movl 8(%ebp), %esi
 221 ; CHECK32-NEXT:    lock cmpxchg8b (%esi)
 222 ; CHECK32-NEXT:    pushl %eax
 223 ; CHECK32-NEXT:    seto %al
 224 ; CHECK32-NEXT:    lahf
 225 ; CHECK32-NEXT:    movl %eax, %esi
 226 ; CHECK32-NEXT:    popl %eax
 227 ; CHECK32-NEXT:    subl $8, %esp
 228 ; CHECK32-NEXT:    pushl %edx
 229 ; CHECK32-NEXT:    pushl %eax
 230 ; CHECK32-NEXT:    calll bar
 231 ; CHECK32-NEXT:    addl $16, %esp
 232 ; CHECK32-NEXT:    movl %esi, %eax
 233 ; CHECK32-NEXT:    addb $127, %al
 234 ; CHECK32-NEXT:    sahf
 235 ; CHECK32-NEXT:    jne .LBB4_3
 236 ; CHECK32-NEXT:  # BB#1: # %t
 237 ; CHECK32-NEXT:    movl $42, %eax
 238 ; CHECK32-NEXT:    jmp .LBB4_2
 239 ; CHECK32-NEXT:  .LBB4_3: # %f
 240 ; CHECK32-NEXT:    xorl %eax, %eax
 241 ; CHECK32-NEXT:  .LBB4_2: # %t
 242 ; CHECK32-NEXT:    xorl %edx, %edx
 243 ; CHECK32-NEXT:    popl %esi
 244 ; CHECK32-NEXT:    popl %ebx
 245 ; CHECK32-NEXT:    popl %ebp
 246 ; CHECK32-NEXT:    retl
 247 ;
 248 ; CHECK64-LABEL: test_intervening_call:
 249 ; CHECK64:       # BB#0: # %entry
 250 ; CHECK64-NEXT:    pushq %rbp
 251 ; CHECK64-NEXT:    movq %rsp, %rbp
 252 ; CHECK64-NEXT:    pushq %rbx
 253 ; CHECK64-NEXT:    pushq %rax
 254 ; CHECK64-NEXT:    movq %rsi, %rax
 255 ; CHECK64-NEXT:    lock cmpxchgq %rdx, (%rdi)
 256 ; CHECK64-NEXT:    pushq %rax
 257 ; CHECK64-NEXT:    seto %al
 258 ; CHECK64-NEXT:    lahf
 259 ; CHECK64-NEXT:    movq %rax, %rbx
 260 ; CHECK64-NEXT:    popq %rax
 261 ; CHECK64-NEXT:    movq %rax, %rdi
 262 ; CHECK64-NEXT:    callq bar
 263 ; CHECK64-NEXT:    movq %rbx, %rax
 264 ; CHECK64-NEXT:    addb $127, %al
 265 ; CHECK64-NEXT:    sahf
 266 ; CHECK64-NEXT:    jne .LBB4_3
 267 ; CHECK64-NEXT:  # BB#1: # %t
 268 ; CHECK64-NEXT:    movl $42, %eax
 269 ; CHECK64-NEXT:    jmp .LBB4_2
 270 ; CHECK64-NEXT:  .LBB4_3: # %f
 271 ; CHECK64-NEXT:    xorl %eax, %eax
 272 ; CHECK64-NEXT:  .LBB4_2: # %t
 273 ; CHECK64-NEXT:    addq $8, %rsp
 274 ; CHECK64-NEXT:    popq %rbx
 275 ; CHECK64-NEXT:    popq %rbp
 276 ; CHECK64-NEXT:    retq
 277 entry:
 278   ; cmpxchg sets EFLAGS, call clobbers it, then br uses EFLAGS.
 279   %cx = cmpxchg i64* %foo, i64 %bar, i64 %baz seq_cst seq_cst
 280   %v = extractvalue { i64, i1 } %cx, 0
 281   %p = extractvalue { i64, i1 } %cx, 1
 282   call i32 @bar(i64 %v)
 283   br i1 %p, label %t, label %f
 284
 285 t:
 286   ret i64 42
 287
 288 f:
 289   ret i64 0
 290 }
 291
 292 define i64 @test_two_live_flags(i64* %foo0, i64 %bar0, i64 %baz0, i64* %foo1, i64 %bar1, i64 %baz1) nounwind {
 293 ; CHECK32-LABEL: test_two_live_flags:
 294 ; CHECK32:       # BB#0: # %entry
 295 ; CHECK32-NEXT:    pushl %ebp
 296 ; CHECK32-NEXT:    movl %esp, %ebp
 297 ; CHECK32-NEXT:    pushl %ebx
 298 ; CHECK32-NEXT:    pushl %edi
 299 ; CHECK32-NEXT:    pushl %esi
 300 ; CHECK32-NEXT:    movl 44(%ebp), %edi
 301 ; CHECK32-NEXT:    movl 12(%ebp), %eax
 302 ; CHECK32-NEXT:    movl 16(%ebp), %edx
 303 ; CHECK32-NEXT:    movl 20(%ebp), %ebx
 304 ; CHECK32-NEXT:    movl 24(%ebp), %ecx
 305 ; CHECK32-NEXT:    movl 8(%ebp), %esi
 306 ; CHECK32-NEXT:    lock cmpxchg8b (%esi)
 307 ; CHECK32-NEXT:    seto %al
 308 ; CHECK32-NEXT:    lahf
 309 ; CHECK32-NEXT:    movl %eax, %esi
 310 ; CHECK32-NEXT:    movl 32(%ebp), %eax
 311 ; CHECK32-NEXT:    movl 36(%ebp), %edx
 312 ; CHECK32-NEXT:    movl %edi, %ecx
 313 ; CHECK32-NEXT:    movl 40(%ebp), %ebx
 314 ; CHECK32-NEXT:    movl 28(%ebp), %edi
 315 ; CHECK32-NEXT:    lock cmpxchg8b (%edi)
 316 ; CHECK32-NEXT:    sete %al
 317 ; CHECK32-NEXT:    pushl %eax
 318 ; CHECK32-NEXT:    movl %esi, %eax
 319 ; CHECK32-NEXT:    addb $127, %al
 320 ; CHECK32-NEXT:    sahf
 321 ; CHECK32-NEXT:    popl %eax
 322 ; CHECK32-NEXT:    jne .LBB5_4
 323 ; CHECK32-NEXT:  # BB#1: # %entry
 324 ; CHECK32-NEXT:    testb %al, %al
 325 ; CHECK32-NEXT:    je .LBB5_4
 326 ; CHECK32-NEXT:  # BB#2: # %t
 327 ; CHECK32-NEXT:    movl $42, %eax
 328 ; CHECK32-NEXT:    jmp .LBB5_3
 329 ; CHECK32-NEXT:  .LBB5_4: # %f
 330 ; CHECK32-NEXT:    xorl %eax, %eax
 331 ; CHECK32-NEXT:  .LBB5_3: # %t
 332 ; CHECK32-NEXT:    xorl %edx, %edx
 333 ; CHECK32-NEXT:    popl %esi
 334 ; CHECK32-NEXT:    popl %edi
 335 ; CHECK32-NEXT:    popl %ebx
 336 ; CHECK32-NEXT:    popl %ebp
 337 ; CHECK32-NEXT:    retl
 338 ;
 339 ; CHECK64-LABEL: test_two_live_flags:
 340 ; CHECK64:       # BB#0: # %entry
 341 ; CHECK64-NEXT:    pushq %rbp
 342 ; CHECK64-NEXT:    movq %rsp, %rbp
 343 ; CHECK64-NEXT:    movq %rsi, %rax
 344 ; CHECK64-NEXT:    lock cmpxchgq %rdx, (%rdi)
 345 ; CHECK64-NEXT:    seto %al
 346 ; CHECK64-NEXT:    lahf
 347 ; CHECK64-NEXT:    movq %rax, %rdx
 348 ; CHECK64-NEXT:    movq %r8, %rax
 349 ; CHECK64-NEXT:    lock cmpxchgq %r9, (%rcx)
 350 ; CHECK64-NEXT:    sete %al
 351 ; CHECK64-NEXT:    pushq %rax
 352 ; CHECK64-NEXT:    movq %rdx, %rax
 353 ; CHECK64-NEXT:    addb $127, %al
 354 ; CHECK64-NEXT:    sahf
 355 ; CHECK64-NEXT:    popq %rax
 356 ; CHECK64-NEXT:    jne .LBB5_3
 357 ; CHECK64-NEXT:  # BB#1: # %entry
 358 ; CHECK64-NEXT:    testb %al, %al
 359 ; CHECK64-NEXT:    je .LBB5_3
 360 ; CHECK64-NEXT:  # BB#2: # %t
 361 ; CHECK64-NEXT:    movl $42, %eax
 362 ; CHECK64-NEXT:    popq %rbp
 363 ; CHECK64-NEXT:    retq
 364 ; CHECK64-NEXT:  .LBB5_3: # %f
 365 ; CHECK64-NEXT:    xorl %eax, %eax
 366 ; CHECK64-NEXT:    popq %rbp
 367 ; CHECK64-NEXT:    retq
 368 entry:
 369   %cx0 = cmpxchg i64* %foo0, i64 %bar0, i64 %baz0 seq_cst seq_cst
 370   %p0 = extractvalue { i64, i1 } %cx0, 1
 371   %cx1 = cmpxchg i64* %foo1, i64 %bar1, i64 %baz1 seq_cst seq_cst
 372   %p1 = extractvalue { i64, i1 } %cx1, 1
 373   %flag = and i1 %p0, %p1
 374   br i1 %flag, label %t, label %f
 375
 376 t:
 377   ret i64 42
 378
 379 f:
 380   ret i64 0
 381 }
 382
 383 define i1 @asm_clobbering_flags(i32* %mem) nounwind {
 384 ; CHECK32-LABEL: asm_clobbering_flags:
 385 ; CHECK32:       # BB#0: # %entry
 386 ; CHECK32-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 387 ; CHECK32-NEXT:    movl (%ecx), %edx
 388 ; CHECK32-NEXT:    testl %edx, %edx
 389 ; CHECK32-NEXT:    setg %al
 390 ; CHECK32-NEXT:    #APP
 391 ; CHECK32-NEXT:    bsfl %edx, %edx
 392 ; CHECK32-NEXT:    #NO_APP
 393 ; CHECK32-NEXT:    movl %edx, (%ecx)
 394 ; CHECK32-NEXT:    retl
 395 ;
 396 ; CHECK64-LABEL: asm_clobbering_flags:
 397 ; CHECK64:       # BB#0: # %entry
 398 ; CHECK64-NEXT:    movl (%rdi), %ecx
 399 ; CHECK64-NEXT:    testl %ecx, %ecx
 400 ; CHECK64-NEXT:    setg %al
 401 ; CHECK64-NEXT:    #APP
 402 ; CHECK64-NEXT:    bsfl %ecx, %ecx
 403 ; CHECK64-NEXT:    #NO_APP
 404 ; CHECK64-NEXT:    movl %ecx, (%rdi)
 405 ; CHECK64-NEXT:    retq
 406 entry:
 407   %val = load i32, i32* %mem, align 4
 408   %cmp = icmp sgt i32 %val, 0
 409   %res = tail call i32 asm "bsfl $1,$0", "=r,r,~{cc},~{dirflag},~{fpsr},~{flags}"(i32 %val)
 410   store i32 %res, i32* %mem, align 4
 411   ret i1 %cmp
 412 }