Introduce the notion of function addresses in Subzero.

src/IceGlobalContext.cpp

Index: src/IceGlobalContext.cpp
diff --git a/src/IceGlobalContext.cpp b/src/IceGlobalContext.cpp
index c8b429fc4b1b4c3d0a88fcf6a4534b82b8226f29..d017ffb5e53b8a18aafa8f371d12888895fce1b5 100644
--- a/src/IceGlobalContext.cpp
+++ b/src/IceGlobalContext.cpp
@@ -12,6 +12,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/ADT/STLExtras.h"
+
 #include <ctype.h> // isdigit(), isupper()
 #include <locale>  // locale
 
@@ -19,6 +21,7 @@
 #include "IceClFlags.h"
 #include "IceDefs.h"
 #include "IceGlobalContext.h"
+#include "IceGlobalInits.h"
 #include "IceOperand.h"
 #include "IceTargetLowering.h"
 #include "IceTimerTree.h"
@@ -289,7 +292,9 @@ IceString GlobalContext::mangleName(const IceString &Name) const {
   return getTestPrefix() + Name;
 }
 
-GlobalContext::~GlobalContext() {}
+GlobalContext::~GlobalContext() {
+  llvm::DeleteContainerPointers(GlobalDeclarations);
+}
 
 Constant *GlobalContext::getConstantInt64(Type Ty, uint64_t ConstantInt64) {
   assert(Ty == IceType_i64);
@@ -385,6 +390,23 @@ ConstantList GlobalContext::getConstantPool(Type Ty) const {
   llvm_unreachable("Unknown type");
 }
 
+FunctionDeclaration *
+GlobalContext::newFunctionDeclaration(const FuncSigType *Signature,
+                                      unsigned CallingConv, unsigned Linkage,
+                                      bool IsProto) {
+  FunctionDeclaration *Func = new FunctionDeclaration(

[jvoung (off chromium), 2014/10/10 23:01:16]

This could potentially use: new (allocate<FunctionDeclaration>())
FunctionDeclaration(...), if you want to use the slab allocator.

W.r.t. future threading, I guess this part will be done before threads are
created and take their stab at translation.

[Karl, 2014/10/13 17:43:02]

The goal is to eventually move to a memory pool and use the new form you
suggest. However, since GlobalVariableDeclarations's still need to be
destructed, I don't want to do such changes yet.

As far as threading, yes this should be done before the threads are created
(since they define the signature of the function).

+      *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());