Subzero: Transform suitable Load/Arith/Store sequences into RMW ops.

src/IceInst.cpp

 //===- subzero/src/IceInst.cpp - High-level instruction implementation ----===//
 //
 //                        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 Inst class, primarily the various
@@ skipping 404 matching lines @@
 InstSelect::InstSelect(Cfg *Func, Variable *Dest, Operand *Condition,
                        Operand *SourceTrue, Operand *SourceFalse)
     : InstHighLevel(Func, Inst::Select, 3, Dest) {
   assert(typeElementType(Condition->getType()) == IceType_i1);
   addSource(Condition);
   addSource(SourceTrue);
   addSource(SourceFalse);
 }
 
 InstStore::InstStore(Cfg *Func, Operand *Data, Operand *Addr)
-    : InstHighLevel(Func, Inst::Store, 2, nullptr) {
+    : InstHighLevel(Func, Inst::Store, 3, nullptr) {
   addSource(Data);
   addSource(Addr);
+  // The 3rd operand is a dummy placeholder for the RMW beacon.
+  addSource(Data);

[jvoung (off chromium), 2015/06/16 17:59:21]

Would it be safer to have nullptr as the dummy? Then the getRmwBeacon() would be
dyn_cast_or_null<...>(). Otherwise what happens if Data is a variable. Would the
Beacon be right?

[Jim Stichnoth, 2015/06/17 00:15:40]

There's a strong assumption that source operands are non-null (see e.g. the
assert in Inst::addSource()), so that's not a possibility.

The main requirement for the default value is that it does not change the
liveness analysis for existing variables in the Cfg.  One possibility is to use
an operand that contains no variables, such as a constant 0 or undef.  But I'm
not thrilled about doing a locked constant pool lookup for that.  Instead, I
chose to reuse the Data operand because if it contains any uses of variables, it
doesn't affect liveness whether there are one versus two uses of the same
variable.

+}
+
+void InstStore::setRmwBeacon(Variable *Beacon) {
+  Dest = llvm::dyn_cast<Variable>(getData());

[jvoung (off chromium), 2015/06/16 17:59:21]

is this okay if Data isn't a variable when setting the rmw beacon?

[Jim Stichnoth, 2015/06/17 00:15:40]

Yes - the RMW optimization should only be calling setRmwBeacon when Data is the
same as the Dest of the preceding arithmetic instruction.

But if that doesn't happen, and Data is not a variable, then Dest gets set to
nullptr and the Store instruction cannot be DCE'd and so the RMW instruction
lowering will remove itself.

+  Srcs[2] = Beacon;
 }
 
 InstSwitch::InstSwitch(Cfg *Func, SizeT NumCases, Operand *Source,
                        CfgNode *LabelDefault)
     : InstHighLevel(Func, Inst::Switch, 1, nullptr), LabelDefault(LabelDefault),
       NumCases(NumCases) {
   addSource(Source);
   Values = Func->allocateArrayOf<uint64_t>(NumCases);
   Labels = Func->allocateArrayOf<CfgNode *>(NumCases);
   // Initialize in case buggy code doesn't set all entries
@@ skipping 302 matching lines @@
   Str << " = load " << Ty << ", " << Ty << "* ";
   dumpSources(Func);
   Str << ", align " << typeAlignInBytes(Ty);
 }
 
 void InstStore::dump(const Cfg *Func) const {
   if (!ALLOW_DUMP)
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Type Ty = getData()->getType();
+  dumpDest(Func);
+  if (Dest)
+    Str << " = ";
   Str << "store " << Ty << " ";
   getData()->dump(Func);
   Str << ", " << Ty << "* ";
   getAddr()->dump(Func);
   Str << ", align " << typeAlignInBytes(Ty);
+  if (getRmwBeacon()) {
+    Str << ", beacon ";
+    getRmwBeacon()->dump(Func);
+  }
 }
 
 void InstSwitch::dump(const Cfg *Func) const {
   if (!ALLOW_DUMP)
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Type Ty = getComparison()->getType();
   Str << "switch " << Ty << " ";
   getSrc(0)->dump(Func);
   Str << ", label %" << getLabelDefault()->getName() << " [\n";
@@ skipping 156 matching lines @@
     // preserve these.
     return true;
   }
   if (!Dest->hasReg() && !SrcVar->hasReg() &&
       Dest->getStackOffset() == SrcVar->getStackOffset())
     return true;
   return false;
 }
 
 } // end of namespace Ice