Created Ice::Instrumentation base class and accompanying hooks.

src/IceInstrumentation.h

Index: src/IceInstrumentation.h
diff --git a/src/IceInstrumentation.h b/src/IceInstrumentation.h
new file mode 100644
index 0000000000000000000000000000000000000000..57aa5edb3ad4238527adf5926471169434043121
--- /dev/null
+++ b/src/IceInstrumentation.h
@@ -0,0 +1,90 @@
+//===- subzero/src/IceInstrumentation.h - ICE instrumentation ---*- C++ -*-===//
+//
+//                        The Subzero Code Generator
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief Declares the Ice::Instrumentation class.
+///
+/// Instrumentation is an abstract class used to drive the instrumentation
+/// process for tools such as AddressSanitizer and MemorySanitizer. It uses a
+/// LoweringContext to enable the insertion of new instructions into a given
+/// Cfg. Although Instrumentation is an abstract class, each of its virtual
+/// functions is has a trivial default implementation to make subclasses more

[Roland McGrath, 2016/06/06 22:28:45]

s/is has/has/

[tlively, 2016/06/07 00:43:06]

Done.

+/// succinct.
+///
+//===----------------------------------------------------------------------===//
+
+#pragma clang diagnostic ignored "-Wunused-parameter"

[Karl, 2016/06/06 22:27:03]

Don't change command line flags within a file, especially an include file.  By
adding this pragma, you have turned off this feature for all later includes!

Rather, fix this as follows:

Replace method headings of methods like

   void foo(t1 arg1, ....) {}

with

   void foo(t1 arg1, ...) {
     (void) arg1;
     ...
    }

The "(void) arg1;" statement will automatically turn off the warning.

[Roland McGrath, 2016/06/06 22:28:45]

Why is this outside the include guard?
And do you really want this in a header file??  Won't it implicitly affect every
source file that does #include "IceInstrumentation.h"?

[tlively, 2016/06/07 00:43:06]

This fix makes the code much larger and uglier. What I meant to do here is

#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
#endif // __clang__

... lots of unused parameters ...

#ifdef __clang__
#pragma clang diagnostic pop
#endif // __clang__

This is used in IceCompileServer.cpp. Would that be ok here or should I accept
the code growth and void the parameters as suggested?

[Karl, 2016/06/07 14:42:40]

Please do NOT add code that changes command line arguments. While using push/pop
localizes it, it doesn't follow coding conventions.

Please add "(void) param;" instructions to the function bodies to remove the
error messages.

+
+
+#ifndef SUBZERO_SRC_ICEASANLOWERING_H

[Karl, 2016/06/06 22:27:03]

The coding convention is that the define name should follow the file path,
substituting '_' for all punctuation, and capitalizing letters.

This naming convention is more likely to avoid naming conflicts than some
arbitrarily chosen name.

Hence, use SUBZERO_SRC_ICEINSTRUMENTATION_H

[tlively, 2016/06/07 00:43:06]

Done.

+#define SUBZERO_SRC_ICEASANLOWERING_H
+
+#include "IceDefs.h"
+
+namespace Ice {
+
+class LoweringContext;
+
+class Instrumentation {
+  Instrumentation() = delete;
+  Instrumentation(const Instrumentation &) = delete;
+  Instrumentation &operator=(const Instrumentation &) = delete;
+
+protected:

[Karl, 2016/06/06 22:27:03]

Generally, we don't like introducing fields before the public API. The public
API should come first, so that it is easy to find.

[tlively, 2016/06/07 00:43:06]

Done.

+  GlobalContext *Ctx;
+
+public:
+  Instrumentation(GlobalContext *Ctx) : Ctx(Ctx) {}
+
+  virtual void instrumentGlobals() {};
+  void instrumentFunc(Cfg *Func);
+
+private:
+  void instrumentInst(LoweringContext &Context);
+  virtual void instrumentFuncStart(LoweringContext &Context) {};
+  virtual void instrumentAlloca(LoweringContext &Context,
+                                const class InstAlloca *Instr) {};
+  virtual void instrumentArithmetic(LoweringContext &Context,
+                                    const class InstArithmetic *Instr) {};
+  virtual void instrumentBr(LoweringContext &Context,
+                            const class InstBr *Instr) {};
+  virtual void instrumentCall(LoweringContext &Context,
+                              const class InstCall *Instr) {};
+  virtual void instrumentCast(LoweringContext &Context,
+                              const class InstCast *Instr) {};
+  virtual void instrumentExtractElement(LoweringContext &Context,
+                                        const class InstExtractElement *Instr) {};
+  virtual void instrumentFcmp(LoweringContext &Context,
+                              const class InstFcmp *Instr) {};
+  virtual void instrumentIcmp(LoweringContext &Context,
+                              const class InstIcmp *Instr) {};
+  virtual void instrumentInsertElement(LoweringContext &Context,
+                                       const class InstInsertElement *Instr) {};
+  virtual void instrumentIntrinsicCall(LoweringContext &Context,
+                                       const class InstIntrinsicCall *Instr) {};
+  virtual void instrumentLoad(LoweringContext &Context,
+                              const class InstLoad *Instr) {};
+  virtual void instrumentPhi(LoweringContext &Context,
+                             const class InstPhi *Instr) {};
+  virtual void instrumentRet(LoweringContext &Context,
+                             const class InstRet *Instr) {};
+  virtual void instrumentSelect(LoweringContext &Context,
+                                const class InstSelect *Instr) {};
+  virtual void instrumentStore(LoweringContext &Context,
+                               const class InstStore *Instr) {};
+  virtual void instrumentSwitch(LoweringContext &Context,
+                                const class InstSwitch *Instr) {};
+  virtual void instrumentUnreachable(LoweringContext &Context,
+                                     const class InstUnreachable *Instr) {};
+  virtual void instrumentLocalVars(Cfg *Func) {};
+};
+
+} // end of namespace Ice
+
+#endif // SUBZERO_SRC_ICEASANLOWERING_H