Add a few Subzero intrinsics (not the atomic ones yet).

src/IceTargetLoweringX8632.cpp

 //===- subzero/src/IceTargetLoweringX8632.cpp - x86-32 lowering -----------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the TargetLoweringX8632 class, which
@@ skipping 1746 matching lines @@
       legalize(Src0, IsSrc1ImmOrReg ? Legal_All : Legal_Reg, true);
   InstX8632Label *Label = InstX8632Label::create(Func, this);
   _cmp(Src0New, Src1);
   _mov(Dest, One);
   _br(getIcmp32Mapping(Inst->getCondition()), Label);
   Context.insert(InstFakeUse::create(Func, Dest));
   _mov(Dest, Zero);
   Context.insert(Label);
 }
 
+void TargetX8632::lowerIntrinsicCall(const InstIntrinsicCall *Instr) {
+  switch (Instr->getIntrinsicInfo().ID) {
+    case AtomicCmpxchg:
+    case AtomicFence:
+    case AtomicFenceAll:
+    case AtomicIsLockFree:
+    case AtomicLoad:
+    case AtomicRMW:
+    case AtomicStore:
+    case Bswap:
+    case Ctlz:
+    case Ctpop:
+    case Cttz:
+      Func->setError("Unhandled intrinsic");
+      return;
+    case Longjmp: {
+      InstCall *Call = makeHelperCall("longjmp", NULL, 2);
+      Call->addArg(Instr->getSrc(1));

[Jim Stichnoth, 2014/06/10 22:58:28]

Change all the Instr->getSrc(N) calls to Instr->getArg(N-1).

[jvoung (off chromium), 2014/06/12 05:48:30]

Done.

Also adding a crosstest runnable test. Currently getting a segfault before I
even hit the memcpy though. Maybe stack alignment problem? Will debug tomorrow.

+      Call->addArg(Instr->getSrc(2));
+      lowerCall(Call);
+      break;
+    }
+    case Memcpy: {
+      // In the future, we could potentially emit an inline memcpy/memset, etc.
+      // for intrinsic calls w/ a known length.
+      InstCall *Call = makeHelperCall("memcpy", NULL, 3);
+      Call->addArg(Instr->getSrc(1));
+      Call->addArg(Instr->getSrc(2));
+      Call->addArg(Instr->getSrc(3));
+      lowerCall(Call);
+      break;
+    }
+    case Memmove: {
+      InstCall *Call = makeHelperCall("memmove", NULL, 3);
+      Call->addArg(Instr->getSrc(1));
+      Call->addArg(Instr->getSrc(2));
+      Call->addArg(Instr->getSrc(3));
+      lowerCall(Call);
+      break;
+    }
+    case Memset: {
+      InstCall *Call = makeHelperCall("memset", NULL, 3);
+      Call->addArg(Instr->getSrc(1));
+      Call->addArg(Instr->getSrc(2));
+      Call->addArg(Instr->getSrc(3));
+      lowerCall(Call);
+      break;
+    }
+    case NaClReadTP: {
+      Constant *Zero = Ctx->getConstantInt(IceType_i32, 0);
+      Operand *Src = OperandX8632MemOffSeg::create(Func, IceType_i32,
+                                                   Zero, Reg_GS);
+      Variable *Dest = Instr->getDest();
+      // Src is already a memory operand, so we need Dest to be a register.
+      Dest->setWeightInfinite();

[Jim Stichnoth, 2014/06/10 22:58:28]

This will force Dest to have a register for the entire function, which may not
be desirable.  The right thing to do is to assign to an infinite-weight
temporary, then assign that temporary to Dest.

  Variable *T = NULL;
  _mov(T, Src);
  _mov(Dest, T);

[jvoung (off chromium), 2014/06/12 05:48:30]

Oops yeah otherwise it could potentially have a pretty long lifetime -- Done.

+      _mov(Dest, Src);
+      break;
+    }
+    case Setjmp: {
+      InstCall *Call = makeHelperCall("setjmp", Instr->getDest(), 1);
+      Call->addArg(Instr->getSrc(1));
+      lowerCall(Call);
+      break;
+    }
+    case Sqrt:
+    case Stacksave:
+    case Stackrestore:
+      Func->setError("Unhandled intrinsic");
+      return;
+    case Trap:
+      _ud2();
+      break;
+  }
+  return;
+}
+
 namespace {
 
 bool isAdd(const Inst *Inst) {
   if (const InstArithmetic *Arith =
           llvm::dyn_cast_or_null<const InstArithmetic>(Inst)) {
     return (Arith->getOp() == InstArithmetic::Add);
   }
   return false;
 }
 
@@ skipping 482 matching lines @@
   // llvm-mc doesn't parse "dword ptr [.L$foo]".
   Str << "dword ptr [L$" << IceType_f32 << "$" << getPoolEntryID() << "]";
 }
 
 template <> void ConstantDouble::emit(GlobalContext *Ctx) const {
   Ostream &Str = Ctx->getStrEmit();
   Str << "qword ptr [L$" << IceType_f64 << "$" << getPoolEntryID() << "]";
 }
 
 } // end of namespace Ice