[x86, AVX] don't add a vzeroupper if that's what the code is already doing (PR27823)

[spatel]

Summary

This isn't the complete fix, but it handles the trivial examples of duplicate vzero* ops in PR27823:
https://llvm.org/bugs/show_bug.cgi?id=27823
...and amusingly, the bogus cases already exist as regression tests, so let's take this baby step.

We'll need to do more in the general case where there's legitimate AVX usage in the function + there's already a vzero in the code.

[RKSimon]

Can we add tests for explicit calls to vzeroall/vzeroupper that is half way through the function with ymm accesses before + after?

[aaboud]

LGTM.
+1 for adding the test Simon mentioned.

[spatel]

In D20477#436382, @RKSimon wrote:

Can we add tests for explicit calls to vzeroall/vzeroupper that is half way through the function with ymm accesses before + after?

Thanks, Simon and Amjad.
I'm not sure of all of the cases that we need to handle, but I've started a file for that purpose with:
rL270375
That's a simplification of the example I noted in:
https://llvm.org/bugs/show_bug.cgi?id=27823#c3

I'll add a FIXME comment to this patch, so we know that this is not the complete solution.

llvm/trunk/lib/Target/X86/X86VZeroUpper.cpp

for (MachineBasicBlock::iterator I = MBB.begin(); I != MBB.end(); ++I) {
     // epilogue will restore YMM registers if needed.
     bool IsReturnFromX86INTR = IsX86INTR && MI->isReturn();
     bool IsControlFlow = MI->isCall() || MI->isReturn();
 
     // Shortcut: don't need to check regular instructions in dirty state.
     if ((!IsControlFlow || IsReturnFromX86INTR) && CurState == EXITS_DIRTY)
       continue;
 
+    // Ignore existing VZERO* instructions.
+    // FIXME: The existence of these instructions should be used to modify the
+    // current state and/or used when deciding whether we need to create a VZU.
+    if (MI->getOpcode() == X86::VZEROALL || MI->getOpcode() == X86::VZEROUPPER)
+      continue;
+
     if (hasYmmReg(MI)) {
       // We found a ymm-using instruction; this could be an AVX instruction,
       // or it could be control flow.
       CurState = EXITS_DIRTY;
       continue;
     }
 
     // Check for control-flow out of the current function (which might

llvm/trunk/test/CodeGen/X86/avx-intrinsics-fast-isel.ll

; X64-NEXT:    retq
   %bc = bitcast <8 x i32> %res to <8 x float>
   ret <8 x float> %bc
 }
 
 define void @test_mm256_zeroall() nounwind {
 ; X32-LABEL: test_mm256_zeroall:
 ; X32:       # BB#0:
 ; X32-NEXT:    vzeroall
-; X32-NEXT:    vzeroupper
 ; X32-NEXT:    retl
 ;
 ; X64-LABEL: test_mm256_zeroall:
 ; X64:       # BB#0:
 ; X64-NEXT:    vzeroall
-; X64-NEXT:    vzeroupper
 ; X64-NEXT:    retq
   call void @llvm.x86.avx.vzeroall()
   ret void
 }
 declare void @llvm.x86.avx.vzeroall() nounwind readnone
 
 define void @test_mm256_zeroupper() nounwind {
 ; X32-LABEL: test_mm256_zeroupper:
 ; X32:       # BB#0:
 ; X32-NEXT:    vzeroupper
-; X32-NEXT:    vzeroupper
 ; X32-NEXT:    retl
 ;
 ; X64-LABEL: test_mm256_zeroupper:
 ; X64:       # BB#0:
 ; X64-NEXT:    vzeroupper
-; X64-NEXT:    vzeroupper
 ; X64-NEXT:    retq
   call void @llvm.x86.avx.vzeroupper()
   ret void
 }
 declare void @llvm.x86.avx.vzeroupper() nounwind readnone
 
 !0 = !{i32 1}

llvm/trunk/test/CodeGen/X86/avx-intrinsics-x86.ll

 }
 declare i32 @llvm.x86.avx.vtestz.ps.256(<8 x float>, <8 x float>) nounwind readnone
 
 
 define void @test_x86_avx_vzeroall() {
 ; AVX-LABEL: test_x86_avx_vzeroall:
 ; AVX:       ## BB#0:
 ; AVX-NEXT:    vzeroall
-; AVX-NEXT:    vzeroupper
 ; AVX-NEXT:    retl
 ;
 ; AVX512VL-LABEL: test_x86_avx_vzeroall:
 ; AVX512VL:       ## BB#0:
 ; AVX512VL-NEXT:    vzeroall
 ; AVX512VL-NEXT:    retl
   call void @llvm.x86.avx.vzeroall()
   ret void
 }
 declare void @llvm.x86.avx.vzeroall() nounwind
 
 
 define void @test_x86_avx_vzeroupper() {
 ; AVX-LABEL: test_x86_avx_vzeroupper:
 ; AVX:       ## BB#0:
 ; AVX-NEXT:    vzeroupper
-; AVX-NEXT:    vzeroupper
 ; AVX-NEXT:    retl
 ;
 ; AVX512VL-LABEL: test_x86_avx_vzeroupper:
 ; AVX512VL:       ## BB#0:
 ; AVX512VL-NEXT:    vzeroupper
 ; AVX512VL-NEXT:    retl
   call void @llvm.x86.avx.vzeroupper()
   ret void