Subzero: lower the rest of the atomic operations.

src/IceTargetLoweringX8632.h

 //===- subzero/src/IceTargetLoweringX8632.h - x86-32 lowering ---*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the TargetLoweringX8632 class, which
@@ skipping 76 matching lines @@
   virtual void lowerLoad(const InstLoad *Inst);
   virtual void lowerPhi(const InstPhi *Inst);
   virtual void lowerRet(const InstRet *Inst);
   virtual void lowerSelect(const InstSelect *Inst);
   virtual void lowerStore(const InstStore *Inst);
   virtual void lowerSwitch(const InstSwitch *Inst);
   virtual void lowerUnreachable(const InstUnreachable *Inst);
   virtual void doAddressOptLoad();
   virtual void doAddressOptStore();
 
+  void lowerAtomicCmpxchg(Variable *DestPrev, Operand *Ptr, Operand *Expected,
+                          Operand *Desired);
   void lowerAtomicRMW(Variable *Dest, uint32_t Operation, Operand *Ptr,
                       Operand *Val);
 
+  typedef void (TargetX8632::*LowerBinOp)(Variable *, Operand *);
+  void expandAtomicRMWAsCmpxchg(LowerBinOp op_lo, LowerBinOp op_hi,
+                                Variable *Dest, Operand *Ptr, Operand *Val);
+
   // Operand legalization helpers.  To deal with address mode
   // constraints, the helpers will create a new Operand and emit
   // instructions that guarantee that the Operand kind is one of those
   // indicated by the LegalMask (a bitmask of allowed kinds).  If the
   // input Operand is known to already meet the constraints, it may be
   // simply returned as the result, without creating any new
   // instructions or operands.
   enum OperandLegalization {
     Legal_None = 0,
     Legal_Reg = 1 << 0, // physical register, not stack location
@@ skipping 54 matching lines @@
   }
   void _br(InstX8632Br::BrCond Condition, InstX8632Label *Label) {
     Context.insert(InstX8632Br::create(Func, Label, Condition));
   }
   void _cdq(Variable *Dest, Operand *Src0) {
     Context.insert(InstX8632Cdq::create(Func, Dest, Src0));
   }
   void _cmp(Operand *Src0, Operand *Src1) {
     Context.insert(InstX8632Icmp::create(Func, Src0, Src1));
   }
+  void _cmpxchg(Operand *DestOrAddr, Variable *Eax, Variable *Desired,

[Jim Stichnoth, 2014/07/08 04:50:19]

This is probably not worth doing now, but in the future it might be nice to be
able to write stylized lowering code like:

  _lock(_cmpxchg(...));

[jvoung (off chromium), 2014/07/08 18:14:07]

Yes that would be pretty sweet syntax.

The issue is what should _lock(InstX8632Lockable) do?  I could make
InstX8632Lockable have a "setLocked()" method, and toggle w/ _lock().

What LLVM does is make LOCK a completely separate instruction. So it would be
like Context.insert(LOCK), but then the syntax would be more like _lock();
_cmpxchg(...);.

I didn't like that because it separates the prefix from the instruction, which
means that say, when you want to know if the instruction is locked (for whatever
reason), you have to look backward a bit.

[jvoung (off chromium), 2014/07/09 17:07:56]

As we discussed, I'll leave this alone for now. The _lock(_inst()) syntax also
requires modifying the relevant _inst() to return the created inst, and
currently the _inst methods are all void.

[Jim Stichnoth, 2014/07/09 18:14:28]

Yeah, I wouldn't like a separate lock instruction either, also because if you
want to delete an instruction, you also have to look back a bit to delete
prefixes as well.

I think we can revisit this once we have more than a small handful of cases
where we want to lower to a locked instruction.

+                bool Locked) {
+    Context.insert(
+        InstX8632Cmpxchg::create(Func, DestOrAddr, Eax, Desired, Locked));
+    // Mark eax as possibly modified by cmpxchg.
+    Context.insert(InstFakeDef::create(Func, Eax));
+  }
+  void _cmpxchg8b(OperandX8632 *Addr, Variable *Edx, Variable *Eax,
+                  Variable *Ecx, Variable *Ebx, bool Locked) {
+    Context.insert(
+        InstX8632Cmpxchg8b::create(Func, Addr, Edx, Eax, Ecx, Ebx, Locked));
+    // Mark edx, and eax as possibly modified by cmpxchg8b.
+    Context.insert(InstFakeDef::create(Func, Edx));
+    Context.insert(InstFakeDef::create(Func, Eax));
+  }
   void _cvt(Variable *Dest, Operand *Src0) {
     Context.insert(InstX8632Cvt::create(Func, Dest, Src0));
   }
   void _div(Variable *Dest, Operand *Src0, Operand *Src1) {
     Context.insert(InstX8632Div::create(Func, Dest, Src0, Src1));
   }
   void _divss(Variable *Dest, Operand *Src0) {
     Context.insert(InstX8632Divss::create(Func, Dest, Src0));
   }
   void _fld(Operand *Src0) { Context.insert(InstX8632Fld::create(Func, Src0)); }
@@ skipping 26 matching lines @@
   }
   void _movzx(Variable *Dest, Operand *Src0) {
     Context.insert(InstX8632Movzx::create(Func, Dest, Src0));
   }
   void _mul(Variable *Dest, Variable *Src0, Operand *Src1) {
     Context.insert(InstX8632Mul::create(Func, Dest, Src0, Src1));
   }
   void _mulss(Variable *Dest, Operand *Src0) {
     Context.insert(InstX8632Mulss::create(Func, Dest, Src0));
   }
+  void _neg(Variable *SrcDest) {
+    Context.insert(InstX8632Neg::create(Func, SrcDest));
+  }
   void _or(Variable *Dest, Operand *Src0) {
     Context.insert(InstX8632Or::create(Func, Dest, Src0));
   }
   void _pop(Variable *Dest) {
     Context.insert(InstX8632Pop::create(Func, Dest));
   }
   void _push(Operand *Src0, bool SuppressStackAdjustment = false) {
     Context.insert(InstX8632Push::create(Func, Src0, SuppressStackAdjustment));
   }
   void _ret(Variable *Src0 = NULL) {
@@ skipping 35 matching lines @@
   void _ucomiss(Operand *Src0, Operand *Src1) {
     Context.insert(InstX8632Ucomiss::create(Func, Src0, Src1));
   }
   void _ud2() { Context.insert(InstX8632UD2::create(Func)); }
   void _xadd(Operand *Dest, Variable *Src, bool Locked) {
     Context.insert(InstX8632Xadd::create(Func, Dest, Src, Locked));
     // The xadd exchanges Dest and Src (modifying Src).
     // Model that update with a FakeDef.
     Context.insert(InstFakeDef::create(Func, Src));
   }
+  void _xchg(Operand *Dest, Variable *Src) {
+    Context.insert(InstX8632Xchg::create(Func, Dest, Src));
+    // The xchg modifies Dest and Src -- model that update with a FakeDef.
+    Context.insert(InstFakeDef::create(Func, Src));

[Jim Stichnoth, 2014/07/08 04:50:19]

If (as suggested earlier) Dest becomes a Variable and Src becomes an Operand,
then the FakeDef would be conditionally inserted.

+  }
   void _xor(Variable *Dest, Operand *Src0) {
     Context.insert(InstX8632Xor::create(Func, Dest, Src0));
   }
 
   bool IsEbpBasedFrame;
   size_t FrameSizeLocals;
   size_t LocalsSizeBytes;
   llvm::SmallBitVector TypeToRegisterSet[IceType_NUM];
   llvm::SmallBitVector ScratchRegs;
   llvm::SmallBitVector RegsUsed;
@@ skipping 27 matching lines @@
   operator=(const TargetGlobalInitX8632 &) LLVM_DELETED_FUNCTION;
   virtual ~TargetGlobalInitX8632() {}
 };
 
 template <> void ConstantFloat::emit(GlobalContext *Ctx) const;
 template <> void ConstantDouble::emit(GlobalContext *Ctx) const;
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETARGETLOWERINGX8632_H