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 <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(GlobalDeclarations);
+}
 
 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");
 }
 
+FunctionDeclaration *
+GlobalContext::newFunctionDeclaration(const FuncSigType *Signature,
+                                      unsigned CallingConv, unsigned Linkage,
+                                      bool IsProto) {
+  FunctionDeclaration *Func = new FunctionDeclaration(
+      *Signature, static_cast<llvm::CallingConv::ID>(CallingConv),
+      static_cast<llvm::GlobalValue::LinkageTypes>(Linkage), IsProto);
+  GlobalDeclarations.push_back(Func);
+  return Func;
+}
+
+VariableDeclaration *GlobalContext::newVariableDeclaration() {
+  VariableDeclaration *Var = new VariableDeclaration();
+  GlobalDeclarations.push_back(Var);
+  return Var;
+}
+
 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