Introduce the notion of function addresses in Subzero.

src/IceGlobalInits.cpp

-//===- subzero/src/IceGlobalInits.cpp - Global initializers ---------------===//
+//===- subzero/src/IceGlobalInits.cpp - Global declarations ---------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
-// This file implements the notion of global addresses and
-// initializers in Subzero.
+// This file implements the notion of function declarations, global
+// variable declarations, and the corresponding variable initializers
+// in Subzero.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Value.h"
 
 #include "IceDefs.h"
+#include "IceGlobalContext.h"
 #include "IceGlobalInits.h"
 #include "IceTypes.h"
 
 namespace {
 char hexdigit(unsigned X) { return X < 10 ? '0' + X : 'A' + X - 10; }
+
+void dumpLinkage(Ice::Ostream &Stream,
+                 llvm::GlobalValue::LinkageTypes Linkage) {
+  switch (Linkage) {
+  case llvm::GlobalValue::ExternalLinkage:
+    Stream << "external";
+    return;
+  case llvm::GlobalValue::InternalLinkage:
+    Stream << "internal";
+    return;
+  default:
+    break;
+  }
+  std::string Buffer;
+  llvm::raw_string_ostream StrBuf(Buffer);
+  StrBuf << "Unknown linkage value: " << Linkage;
+  llvm::report_fatal_error(StrBuf.str());
 }
 
+void dumpCallingConv(Ice::Ostream &, llvm::CallingConv::ID CallingConv) {
+  if (CallingConv == llvm::CallingConv::C)
+    return;
+  std::string Buffer;
+  llvm::raw_string_ostream StrBuf(Buffer);
+  StrBuf << "Unknown calling convention: " << CallingConv;
+  llvm::report_fatal_error(StrBuf.str());
+}
+
+} // end of anonymous namespace
+
 namespace Ice {
 
-GlobalAddress::~GlobalAddress() { llvm::DeleteContainerPointers(Initializers); }
+IceString GlobalDeclaration::mangleName(GlobalContext *Ctx) const {
+  return (getIsExternal() && !hasInitializer()) ? Name : Ctx->mangleName(Name);

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

Is it possible that IsExternal can hasInitializer()?

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

It can if you are assuming the block definition as an initializer.

I originally factored out getIsExternal and hasInitializer as virtuals, so that
we could use it to mangleName in one context. I realized later that there were
several spots that we want the same effect, and factored out this function.

Changing so that hasInitializer is not virtual, and making mangleName virtual.
This should clean this up.

+}
 
-void GlobalAddress::dumpType(Ostream &Stream) const {
+FunctionDeclaration *
+FunctionDeclaration::create(GlobalContext *Ctx, const FuncSigType &Signature,
+                            llvm::CallingConv::ID CallingConv,
+                            llvm::GlobalValue::LinkageTypes Linkage,
+                            bool IsProto) {
+  return Ctx->newFunctionDeclaration(&Signature, CallingConv, Linkage, IsProto);
+}
+
+void FunctionDeclaration::dumpType(Ostream &Stream) const {
+  Stream << Signature;
+}
+
+void FunctionDeclaration::dump(Ostream &Stream) const {
+  if (IsProto)
+    Stream << "declare ";
+  ::dumpLinkage(Stream, Linkage);
+  ::dumpCallingConv(Stream, CallingConv);
+  Stream << Signature.getReturnType() << " @" << Name << "(";
+  bool IsFirst = true;
+  for (Type ArgTy : Signature.getArgList()) {
+    if (IsFirst)
+      IsFirst = false;
+    else
+      Stream << ", ";
+    Stream << ArgTy;
+  }
+  Stream << ")";
+}
+
+VariableDeclaration *VariableDeclaration::create(GlobalContext *Ctx) {
+  return Ctx->newVariableDeclaration();
+}
+
+VariableDeclaration::~VariableDeclaration() {
+  llvm::DeleteContainerPointers(Initializers);
+}
+
+void VariableDeclaration::dumpType(Ostream &Stream) const {
   if (Initializers.size() == 1) {
     Initializers.front()->dumpType(Stream);
   } else {
     Stream << "<{ ";
     bool IsFirst = true;
     for (Initializer *Init : Initializers) {
       if (IsFirst) {
         IsFirst = false;
       } else {
         Stream << ", ";
       }
       Init->dumpType(Stream);
     }
     Stream << " }>";
   }
 }
 
-void GlobalAddress::dump(Ostream &Stream) const {
-  Stream << "@" << getName() << " = internal "
+void VariableDeclaration::dump(Ostream &Stream) const {
+  Stream << "@" << Name << " = internal "
          << (IsConstant ? "constant" : "global") << " ";
 
   // Add initializer.
   if (Initializers.size() == 1) {
     Initializers.front()->dump(Stream);
   } else {
     dumpType(Stream);
     Stream << " <{ ";
     bool IsFirst = true;
     for (Initializer *Init : Initializers) {
       if (IsFirst) {
         IsFirst = false;
       } else {
         Stream << ", ";
       }
       Init->dump(Stream);
     }
     Stream << " }>";
   }
 
   // Add alignment.
   if (Alignment > 0)
     Stream << ", align " << Alignment;
   Stream << "\n";
 }
 
-void GlobalAddress::Initializer::dumpType(Ostream &Stream) const {
+void VariableDeclaration::Initializer::dumpType(Ostream &Stream) const {
   Stream << "[" << getNumBytes() << " x " << Ice::IceType_i8 << "]";
 }
 
-void GlobalAddress::DataInitializer::dump(Ostream &Stream) const {
+void VariableDeclaration::DataInitializer::dump(Ostream &Stream) const {
   dumpType(Stream);
   Stream << " c\"";
   // Code taken from PrintEscapedString() in AsmWriter.cpp.  Keep
   // the strings in the same format as the .ll file for practical
   // diffing.
   for (uint8_t C : Contents) {
     if (isprint(C) && C != '\\' && C != '"')
       Stream << C;
     else
       Stream << '\\' << hexdigit(C >> 4) << hexdigit(C & 0x0F);
   }
   Stream << "\"";
 }
 
-void GlobalAddress::ZeroInitializer::dump(Ostream &Stream) const {
+void VariableDeclaration::ZeroInitializer::dump(Ostream &Stream) const {
   dumpType(Stream);
   Stream << " zeroinitializer";
 }
 
-IceString GlobalAddress::RelocInitializer::getName() const {
-  switch (Address.getKind()) {
-  case FunctionRelocation:
-    return Address.getFunction()->getName();
-  case GlobalAddressRelocation:
-    return Address.getGlobalAddr()->getName();
-  default:
-    llvm::report_fatal_error("Malformed relocation address!");
-  }
-}
-
-void GlobalAddress::RelocInitializer::dumpType(Ostream &Stream) const {
+void VariableDeclaration::RelocInitializer::dumpType(Ostream &Stream) const {
   Stream << Ice::IceType_i32;
 }
 
-void GlobalAddress::RelocInitializer::dump(Ostream &Stream) const {
+void VariableDeclaration::RelocInitializer::dump(Ostream &Stream) const {
   if (Offset != 0) {
     dumpType(Stream);
     Stream << " add (";
   }
   dumpType(Stream);
   Stream << " ptrtoint (";
-  if (Address.getKind() == FunctionRelocation) {
-    Stream << *Address.getFunction()->getType() << " @"
-           << Address.getFunction()->getName();
-  } else {
-    Address.getGlobalAddr()->dumpType(Stream);
-    Stream << "* @" << Address.getGlobalAddr()->getName();
-  }
-  Stream << " to ";
+  Declaration->dumpType(Stream);
+  Stream << "* @" << Declaration->getName() << " to ";
   dumpType(Stream);
   Stream << ")";
   if (Offset != 0) {
     Stream << ", ";
     dumpType(Stream);
     Stream << " " << Offset << ")";
   }
 }
-}
+
+} // end of namespace Ice