[X86] Disable argument copy elision for arguments passed via pointers

[craig.topper]

Summary

If you pass two 1024 bit vectors in IR with AVX2 on Windows 64. Both vectors will be split in four 256 bit pieces. The four pieces of the first argument will be passed indirectly using 4 gprs. The second argument will get passed via pointers in memory.

The PartOffsets stored for the second argument are all in terms of its original 1024 bit size. So the PartOffsets for each piece are 32 bytes apart. So if we consider it for copy elision we'll only load an 8 byte pointer, but we'll move the address 32 bytes. The stack object size we create for the first part is probably wrong too.

This issue was encountered by ISPC. I'm working on getting a reduce test case, but wanted to go ahead and get feedback on the fix.

[rnk]

The code change seems reasonable to me. I looked at it for a while, but I struggled to find a way to simplify it.

llvm/lib/Target/X86/X86ISelLowering.cpp

3013–3014 ↗

(On Diff #195474)

I think this comment needs to be reworked, since things aren't as simple as I thought they were. Something like:

// If the argument is passed directly in memory without any extension, then we can perform copy elision.
// Large vector types, for example, may be passed indirectly by pointer.

[rnk]

lgtm

This is a really strange legalization. =/ I'm surprised we split the vector, and then pass the pieces indirectly instead of passing the entire <16 x double> indirectly.

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

if (Flags.isByVal()) {
     // FIXME: For now, all byval parameter objects are marked as aliasing. This
     // can be improved with deeper analysis.
     int FI = MFI.CreateFixedObject(Bytes, VA.getLocMemOffset(), isImmutable,
                                    /*isAliased=*/true);
     return DAG.getFrameIndex(FI, PtrVT);
   }
 
   // This is an argument in memory. We might be able to perform copy elision.
-  if (Flags.isCopyElisionCandidate()) {
+  // If the argument is passed directly in memory without any extension, then we
+  // can perform copy elision. Large vector types, for example, may be passed
+  // indirectly by pointer.
+  if (Flags.isCopyElisionCandidate() &&
+      VA.getLocInfo() != CCValAssign::Indirect && !ExtendedInMem) {
     EVT ArgVT = Ins[i].ArgVT;
     SDValue PartAddr;
     if (Ins[i].PartOffset == 0) {
       // If this is a one-part value or the first part of a multi-part value,
       // create a stack object for the entire argument value type and return a
       // load from our portion of it. This assumes that if the first part of an
       // argument is in memory, the rest will also be in memory.
       int FI = MFI.CreateFixedObject(ArgVT.getStoreSize(), VA.getLocMemOffset(),

llvm/trunk/test/CodeGen/X86/arg-copy-elide-win64.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc < %s -mtriple=x86_64-windows-msvc -mattr=avx2 | FileCheck %s
 
 ; Make sure we don't try to copy elide these arguments since they will be
 ; passed indirectly.
 define void @baz(<16 x double> %arg, <16 x double> %arg1) #0 {
 ; CHECK-LABEL: baz:
 ; CHECK:       # %bb.0: # %bb
 ; CHECK-NEXT:    pushq %rbp
 ; CHECK-NEXT:    subq $368, %rsp # imm = 0x170
 ; CHECK-NEXT:    leaq {{[0-9]+}}(%rsp), %rbp
 ; CHECK-NEXT:    vmovaps %xmm7, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 ; CHECK-NEXT:    vmovaps %xmm6, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 ; CHECK-NEXT:    andq $-128, %rsp
 ; CHECK-NEXT:    movq 288(%rbp), %rax
-; CHECK-NEXT:    movq 320(%rbp), %r10
 ; CHECK-NEXT:    vmovaps (%rax), %ymm0
-; CHECK-NEXT:    vmovaps (%r10), %ymm1
-; CHECK-NEXT:    movq 352(%rbp), %rax
+; CHECK-NEXT:    movq 296(%rbp), %rax
+; CHECK-NEXT:    vmovaps (%rax), %ymm1
+; CHECK-NEXT:    movq 304(%rbp), %rax
 ; CHECK-NEXT:    vmovaps (%rax), %ymm2
-; CHECK-NEXT:    movq 384(%rbp), %rax
+; CHECK-NEXT:    movq 312(%rbp), %rax
 ; CHECK-NEXT:    vmovaps (%rax), %ymm3
 ; CHECK-NEXT:    vmovaps (%rcx), %ymm4
 ; CHECK-NEXT:    vmovaps (%rdx), %ymm5
 ; CHECK-NEXT:    vmovaps (%r8), %ymm6
 ; CHECK-NEXT:    vmovaps (%r9), %ymm7
 ; CHECK-NEXT:    vmovaps %ymm7, {{[0-9]+}}(%rsp)
 ; CHECK-NEXT:    vmovaps %ymm6, {{[0-9]+}}(%rsp)
 ; CHECK-NEXT:    vmovaps %ymm5, {{[0-9]+}}(%rsp)