Introduce the notion of function addresses in Subzero.

src/IceGlobalContext.cpp

 //===- subzero/src/IceGlobalContext.cpp - Global context defs -------------===//
 //
 //                        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 "llvm/ADT/STLExtras.h"
+
 #include <ctype.h> // isdigit(), isupper()
 #include <locale>  // locale
 
 #include "IceCfg.h"
 #include "IceClFlags.h"
 #include "IceDefs.h"
 #include "IceGlobalContext.h"
+#include "IceGlobalInits.h"
 #include "IceOperand.h"
 #include "IceTargetLowering.h"
 #include "IceTimerTree.h"
 #include "IceTypes.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.
@@ skipping 250 matching lines @@
              OrigSuffix.data());
     incrementSubstitutions(NewName);
     return NewName.data();
   }
 
   // Transform bar ==> Prefixbar
   //                   ^^^^^^
   return getTestPrefix() + Name;
 }
 
-GlobalContext::~GlobalContext() {}
+GlobalContext::~GlobalContext() {
+  llvm::DeleteContainerPointers(GlobalAddresses);
+}
 
 Constant *GlobalContext::getConstantInt64(Type Ty, uint64_t ConstantInt64) {
   assert(Ty == IceType_i64);
   return ConstPool->Integers64.getOrAdd(this, Ty, ConstantInt64);
 }
 
 Constant *GlobalContext::getConstantInt32(Type Ty, uint32_t ConstantInt32) {
   if (Ty == IceType_i1)
     ConstantInt32 &= UINT32_C(1);
   return ConstPool->Integers32.getOrAdd(this, Ty, ConstantInt32);
@@ skipping 75 matching lines @@
     BaseOS << "Unsupported constant type: " << Ty;
     llvm_unreachable(BaseOS.str().c_str());
   } break;
   case IceType_void:
   case IceType_NUM:
     break;
   }
   llvm_unreachable("Unknown type");
 }
 
+Function *GlobalContext::newFunction(const FuncSigType *Signature,
+                                     unsigned CallingConv, unsigned Linkage,
+                                     bool IsProto) {
+  Function *Func = new Function(
+      *Signature, static_cast<llvm::CallingConv::ID>(CallingConv),
+      static_cast<llvm::GlobalValue::LinkageTypes>(Linkage), IsProto);
+  GlobalAddresses.push_back(Func);
+  return Func;
+}
+
+GlobalVariable *GlobalContext::newGlobalVariable() {
+  GlobalVariable *Vbl = new GlobalVariable();

[jvoung (off chromium), 2014/10/10 01:47:28]

Most abbreviations of "Variable" are "Var" in the other code.

[Karl, 2014/10/10 20:17:30]

Done.

+  GlobalAddresses.push_back(Vbl);
+  return Vbl;
+}
+
 TimerIdT GlobalContext::getTimerID(TimerStackIdT StackID,
                                    const IceString &Name) {
   assert(StackID < Timers.size());
   return Timers[StackID].getTimerID(Name);
 }
 
 TimerStackIdT GlobalContext::newTimerStackID(const IceString &Name) {
   TimerStackIdT NewID = Timers.size();
   Timers.push_back(TimerStack(Name));
   return NewID;
@@ skipping 37 matching lines @@
 }
 
 TimerMarker::TimerMarker(TimerIdT ID, const Cfg *Func)
     : ID(ID), Ctx(Func->getContext()),
       Active(Func->getFocusedTiming() || Ctx->getFlags().SubzeroTimingEnabled) {
   if (Active)
     Ctx->pushTimer(ID);
 }
 
 } // end of namespace Ice