Subzero: Improve register availability peephole for function return values.

src/IceTargetLoweringX86BaseImpl.h

 //===- subzero/src/IceTargetLoweringX86BaseImpl.h - x86 lowering -*- C++ -*-==//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 2670 matching lines @@
   // Emit the call to the function.
   Operand *CallTarget =
       legalize(Instr->getCallTarget(), Legal_Reg | Legal_Imm | Legal_AddrAbs);
   Inst *NewCall = emitCallToTarget(CallTarget, ReturnReg);
   // Keep the upper return register live on 32-bit platform.
   if (ReturnRegHi)
     Context.insert<InstFakeDef>(ReturnRegHi);
   // Mark the call as killing all the caller-save registers.
   Context.insert<InstFakeKill>(NewCall);
   // Handle x86-32 floating point returns.
-  if (Dest != nullptr && isScalarFloatingType(Dest->getType()) &&
+  if (Dest != nullptr && isScalarFloatingType(DestTy) &&
       !Traits::X86_PASS_SCALAR_FP_IN_XMM) {
     // Special treatment for an FP function which returns its result in st(0).
     // If Dest ends up being a physical xmm register, the fstp emit code will
     // route st(0) through the space reserved in the function argument area
     // we allocated.
     _fstp(Dest);
     // Create a fake use of Dest in case it actually isn't used, because st(0)
     // still needs to be popped.
     Context.insert<InstFakeUse>(Dest);
   }
   // Generate a FakeUse to keep the call live if necessary.
   if (Instr->hasSideEffects() && ReturnReg) {
     Context.insert<InstFakeUse>(ReturnReg);
   }
   // Process the return value, if any.
   if (Dest == nullptr)
     return;
-  // Assign the result of the call to Dest.
+  // Assign the result of the call to Dest.  Route it through a temporary so
+  // that the local register availability peephole can be subsequently used.
+  Variable *Tmp = nullptr;
   if (isVectorType(DestTy)) {
     assert(ReturnReg && "Vector type requires a return register");
-    _movp(Dest, ReturnReg);
+    Tmp = makeReg(DestTy);
+    _movp(Tmp, ReturnReg);
+    _movp(Dest, Tmp);
   } else if (isScalarFloatingType(DestTy)) {
     if (Traits::X86_PASS_SCALAR_FP_IN_XMM) {
       assert(ReturnReg && "FP type requires a return register");
-      _mov(Dest, ReturnReg);
+      _mov(Tmp, ReturnReg);
+      _mov(Dest, Tmp);
     }
   } else {
     assert(isScalarIntegerType(DestTy));
     assert(ReturnReg && "Integer type requires a return register");
     if (DestTy == IceType_i64 && !Traits::Is64Bit) {
       assert(ReturnRegHi && "64-bit type requires two return registers");
       auto *Dest64On32 = llvm::cast<Variable64On32>(Dest);
       Variable *DestLo = Dest64On32->getLo();
       Variable *DestHi = Dest64On32->getHi();
-      _mov(DestLo, ReturnReg);
-      _mov(DestHi, ReturnRegHi);
+      _mov(Tmp, ReturnReg);
+      _mov(DestLo, Tmp);
+      Variable *TmpHi = nullptr;

[Eric Holk, 2016/06/15 00:14:38]

Why is it okay for TmpHi to be NULL?

[Jim Stichnoth, 2016/06/15 00:35:31]

The _mov() method is "special" in that if the dest arg is nullptr it
automatically creates a new temporary of the appropriate type via makeReg(). 
The same is being done for "Variable *Tmp = nullptr;" above.

+      _mov(TmpHi, ReturnRegHi);
+      _mov(DestHi, TmpHi);
     } else {
-      _mov(Dest, ReturnReg);
+      _mov(Tmp, ReturnReg);
+      _mov(Dest, Tmp);
     }
   }
 }
 
 template <typename TraitsType>
 void TargetX86Base<TraitsType>::lowerCast(const InstCast *Instr) {
   // a = cast(b) ==> t=cast(b); a=t; (link t->b, link a->t, no overlap)
   InstCast::OpKind CastKind = Instr->getCastKind();
   Variable *Dest = Instr->getDest();
   Type DestTy = Dest->getType();
@@ skipping 5231 matching lines @@
         emitGlobal(*Var, SectionSuffix);
       }
     }
   } break;
   }
 }
 } // end of namespace X86NAMESPACE
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETARGETLOWERINGX86BASEIMPL_H