Add Om1 lowering with no optimizations

src/IceGlobalContext.cpp

 //===- subzero/src/IceGlobalContext.cpp - Global context defs ---*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines aspects of the compilation that persist across
 // multiple functions.
 //
 //===----------------------------------------------------------------------===//
 
 #include "IceDefs.h"
 #include "IceTypes.h"
 #include "IceCfg.h"
 #include "IceGlobalContext.h"
 #include "IceOperand.h"
+#include "IceTargetLowering.h"
 
 namespace Ice {
 
 // TypePool maps constants of type KeyType (e.g. float) to pointers to
 // type ValueType (e.g. ConstantFloat).  KeyType values are compared
 // using memcmp() because of potential NaN values in KeyType values.
 // KeyTypeHasFP indicates whether KeyType is a floating-point type
 // whose values need to be compared using memcmp() for NaN
 // correctness.  TODO: use std::is_floating_point<KeyType> instead of
 // KeyTypeHasFP with C++11.
@@ skipping 38 matching lines @@
 public:
   ConstantPool() {}
   TypePool<float, ConstantFloat, true> Floats;
   TypePool<double, ConstantDouble, true> Doubles;
   TypePool<uint64_t, ConstantInteger> Integers;
   TypePool<RelocatableTuple, ConstantRelocatable> Relocatables;
 };
 
 GlobalContext::GlobalContext(llvm::raw_ostream *OsDump,
                              llvm::raw_ostream *OsEmit, VerboseMask Mask,
+                             TargetArch Arch, OptLevel Opt,
                              IceString TestPrefix)
     : StrDump(OsDump), StrEmit(OsEmit), VMask(Mask),
-      ConstPool(new ConstantPool()), TestPrefix(TestPrefix) {}
+      ConstPool(new ConstantPool()), Arch(Arch), Opt(Opt),
+      TestPrefix(TestPrefix), HasEmittedFirstMethod(false) {}
 
 // In this context, name mangling means to rewrite a symbol using a
 // given prefix.  For a C++ symbol, nest the original symbol inside
 // the "prefix" namespace.  For other symbols, just prepend the
 // prefix.
 IceString GlobalContext::mangleName(const IceString &Name) const {
   // TODO: Add explicit tests (beyond the implicit tests in the linker
   // that come from the cross tests).
   //
   // An already-nested name like foo::bar() gets pushed down one
   // level, making it equivalent to Prefix::foo::bar().
   //   _ZN3foo3barExyz ==> _ZN6Prefix3foo3barExyz
   // A non-nested but mangled name like bar() gets nested, making it
   // equivalent to Prefix::bar().
   //   _Z3barxyz ==> ZN6Prefix3barExyz
   // An unmangled, extern "C" style name, gets a simple prefix:
   //   bar ==> Prefixbar
   if (getTestPrefix().empty())
     return Name;
 
   unsigned PrefixLength = getTestPrefix().length();
   char NameBase[1 + Name.length()];
-  const size_t BufLen = 30 + Name.length() + getTestPrefix().length();
+  const size_t BufLen = 30 + Name.length() + PrefixLength;
   char NewName[BufLen];
-  uint32_t BaseLength = 0;
+  uint32_t BaseLength = 0; // using uint32_t due to sscanf format string
 
   int ItemsParsed = sscanf(Name.c_str(), "_ZN%s", NameBase);
   if (ItemsParsed == 1) {
     // Transform _ZN3foo3barExyz ==> _ZN6Prefix3foo3barExyz
     //   (splice in "6Prefix")          ^^^^^^^
     snprintf(NewName, BufLen, "_ZN%u%s%s", PrefixLength,
              getTestPrefix().c_str(), NameBase);
     // We ignore the snprintf return value (here and below).  If we
     // somehow miscalculated the output buffer length, the output will
     // be truncated, but it will be truncated consistently for all
@@ skipping 44 matching lines @@
 
 void Timer::printElapsedUs(GlobalContext *Ctx, const IceString &Tag) const {
   if (Ctx->isVerbose(IceV_Timing)) {
     // Prefixing with '#' allows timing strings to be included
     // without error in textual assembly output.
     Ctx->getStrDump() << "# " << getElapsedUs() << " usec " << Tag << "\n";
   }
 }
 
 } // end of namespace Ice