Subzero: Basic Block Profiler.

src/IceCfgNode.cpp

 //===- subzero/src/IceCfgNode.cpp - Basic block (node) 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 CfgNode class, including the complexities
 // of instruction insertion and in-edge calculation.
 //
 //===----------------------------------------------------------------------===//
 
 #include "assembler.h"
 #include "IceCfg.h"
 #include "IceCfgNode.h"
+#include "IceGlobalInits.h"
 #include "IceInst.h"
 #include "IceLiveness.h"
 #include "IceOperand.h"
 #include "IceTargetLowering.h"
 
 namespace Ice {
 
 CfgNode::CfgNode(Cfg *Func, SizeT LabelNumber)
     : Func(Func), Number(LabelNumber), NameIndex(Cfg::IdentifierIndexInvalid),
       HasReturn(false), NeedsPlacement(false), InstCountEstimate(0) {}
@@ skipping 1208 matching lines @@
     for (CfgNode *I : OutEdges) {
       if (!First)
         Str << ", ";
       First = false;
       Str << "%" << I->getName();
     }
     Str << "\n";
   }
 }
 
+void CfgNode::profileExecutionCount(VariableDeclaration *Var) {
+  constexpr char RMW_I64[] = "llvm.nacl.atomic.rmw.i64";
+
+  auto *Context = Func->getContext();

[Jim Stichnoth, 2015/06/08 23:45:31]

In Subzero, we've been more sparing with our use of "auto".  I think the
generalization is that auto is OK if:

- the type is redundant, e.g. "auto *V = llvm::dyn_cast<Variable>(O);"

- there is otherwise some horribly verbose type like with iterators

- the type is blindingly obvious or available a few lines away

For the cluster starting with RMWI64Name, I would use Operand* .

[John, 2015/06/09 15:36:18]

Done. I was just following items 5 and 6 from Modern Effective C++: "Prefer auto
to explicit type declarations," and "Use the explicit type initializer idiom
when auto deduces undesired types."

[Jim Stichnoth, 2015/06/09 16:39:46]

I'm fairly new to "auto" and as such, the code base has many inconsistencies and
needs to have a separate cleanup pass, assuming we settle on an "official"
policy.

When we switched over to C++11, I went a bit auto-crazy, and then pulled back a
bit based on JF's (fairly strong) opinions on the matter...

+
+  bool BadIntrinsic = false;
+  auto *Info = Context->getIntrinsicsInfo().find(RMW_I64, BadIntrinsic);
+  assert(!BadIntrinsic);
+  assert(Info != nullptr);
+
+  auto *RMWI64Name = Context->getConstantExternSym(RMW_I64);
+  auto *Counter = Context->getConstantExternSym(Var->getName());
+  auto *AtomicRMWOp = Context->getConstantInt32(Intrinsics::AtomicAdd);
+  auto *One = Context->getConstantInt64(1);
+  auto *OrderAcquireRelease =
+      Context->getConstantInt32(Intrinsics::MemoryOrderAcquireRelease);
+
+  InstIntrinsicCall *Inst = InstIntrinsicCall::create(
+      Func, 5, Func->makeVariable(IceType_i64), RMWI64Name, Info->Info);
+  Inst->addArg(AtomicRMWOp);
+  Inst->addArg(Counter);
+  Inst->addArg(One);
+  Inst->addArg(OrderAcquireRelease);
+  Insts.push_front(Inst);
+}
+
 } // end of namespace Ice