ARM32 Vector lowering - scalarize select

src/IceTargetLowering.cpp

 //===- subzero/src/IceTargetLowering.cpp - Basic lowering implementation --===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 290 matching lines @@
 
 TargetLowering::AutoBundle::~AutoBundle() {
   assert(Target->AutoBundling);
   Target->AutoBundling = false;
   if (NeedSandboxing) {
     Target->_bundle_unlock();
   }
 }
 
 void TargetLowering::genTargetHelperCalls() {
+  GeneratingTargetHelpers = true;

[Jim Stichnoth, 2016/02/12 02:32:50]

It would be nice to use a RAII helper object for this.

Maybe BoolFlagSaver could be lifted out of the x86 target and used here.

I don't know whether I would put it in IceDefs.h, IceUtils.h,
IceTargetLowering.h, or what.

[Eric Holk, 2016/02/12 18:38:15]

Done.

   for (CfgNode *Node : Func->getNodes()) {
     Context.init(Node);
     while (!Context.atEnd()) {
       PostIncrLoweringContext _(Context);
       genTargetHelperCallFor(Context.getCur());
     }
   }
+  GeneratingTargetHelpers = false;
 }
 
 void TargetLowering::doAddressOpt() {
   if (llvm::isa<InstLoad>(*Context.getCur()))
     doAddressOptLoad();
   else if (llvm::isa<InstStore>(*Context.getCur()))
     doAddressOptStore();
   Context.advanceCur();
   Context.advanceNext();
 }
@@ skipping 371 matching lines @@
 
 bool TargetLowering::shouldOptimizeMemIntrins() {
   return Ctx->getFlags().getOptLevel() >= Opt_1 ||
          Ctx->getFlags().getForceMemIntrinOpt();
 }
 
 void TargetLowering::scalarizeArithmetic(InstArithmetic::OpKind Kind,
                                          Variable *Dest, Operand *Src0,
                                          Operand *Src1) {
   scalarizeInstruction(
-      Dest, Src0, Src1,
-      [this, Kind](Variable *Dest, Variable *Src0, Variable *Src1) {
+      Dest, [this, Kind](Variable *Dest, Operand *Src0, Operand *Src1) {
         return Context.insert<InstArithmetic>(Kind, Dest, Src0, Src1);
-      });
+      }, Src0, Src1);
 }
 
 void TargetLowering::emitWithoutPrefix(const ConstantRelocatable *C,
                                        const char *Suffix) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Ctx->getStrEmit();
   const IceString &EmitStr = C->getEmitString();
   if (!EmitStr.empty()) {
     // C has a custom emit string, so we use it instead of the canonical
@@ skipping 152 matching lines @@
   case Target_##X:                                                             \
     return ::X::createTargetHeaderLowering(Ctx);
 #include "llvm/Config/SZTargets.def"
 #undef SUBZERO_TARGET
   }
 }
 
 TargetHeaderLowering::~TargetHeaderLowering() = default;
 
 } // end of namespace Ice