Introduce the notion of function addresses in Subzero.

src/IceTargetLoweringX8632.cpp

 //===- subzero/src/IceTargetLoweringX8632.cpp - x86-32 lowering -----------===//
 //
 //                        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 TargetLoweringX8632 class, which
@@ skipping 4409 matching lines @@
   Str << "qword ptr [L$" << IceType_f64 << "$" << getPoolEntryID() << "]";
 }
 
 void ConstantUndef::emit(GlobalContext *) const {
   llvm_unreachable("undef value encountered by emitter.");
 }
 
 TargetGlobalInitX8632::TargetGlobalInitX8632(GlobalContext *Ctx)
     : TargetGlobalInitLowering(Ctx) {}
 
-void TargetGlobalInitX8632::lower(const GlobalAddress &Global,
-                                  bool DisableTranslation) {
-  if (Ctx->isVerbose()) {
-    Global.dump(Ctx->getStrDump());
-  }
-
-  if (DisableTranslation)
-    return;
+void TargetGlobalInitX8632::lower(const VariableDeclaration &Var) {
 
   Ostream &Str = Ctx->getStrEmit();
 
-  // TODO(kschimpf): Don't mangle name if external and uninitialized. This
-  // will allow us to cross test relocations for references to external
-  // global variables.
-
-  const GlobalAddress::InitializerListType &Initializers =
-      Global.getInitializers();
+  const VariableDeclaration::InitializerListType &Initializers =
+      Var.getInitializers();
   assert(Initializers.size());
-  bool HasInitializer =
-      !(Initializers.size() == 1 &&
-        llvm::isa<GlobalAddress::ZeroInitializer>(Initializers[0]));
-  bool IsConstant = Global.getIsConstant();
-  bool IsExternal = !Global.getIsInternal();
-  uint32_t Align = Global.getAlignment();
-  SizeT Size = Global.getNumBytes();
-  IceString MangledName = Ctx->mangleName(Global.getName());
+  bool HasInitializer = Var.hasInitializer();
+  bool IsConstant = Var.getIsConstant();
+  bool IsExternal = Var.getIsExternal();
+  uint32_t Align = Var.getAlignment();
+  SizeT Size = Var.getNumBytes();
+  IceString MangledName = Var.mangleName(Ctx);
   IceString SectionSuffix = "";
   if (Ctx->getFlags().DataSections)
     SectionSuffix = "." + MangledName;
 
   Str << "\t.type\t" << MangledName << ",@object\n";
 
   if (IsConstant)
     Str << "\t.section\t.rodata" << SectionSuffix << ",\"a\",@progbits\n";
   else if (HasInitializer)
     Str << "\t.section\t.data" << SectionSuffix << ",\"aw\",@progbits\n";
@@ skipping 10 matching lines @@
   if ((IsConstant || HasInitializer || IsExternal) && Align > 1)
     Str << "\t.align\t" << Align << "\n";
   // Alignment is part of .comm.
 
   if (IsConstant || HasInitializer || IsExternal)
     Str << MangledName << ":\n";
   else
     Str << "\t.comm\t" << MangledName << "," << Size << "," << Align << "\n";
 
   if (HasInitializer) {
-    for (GlobalAddress::Initializer *Init : Initializers) {
+    for (VariableDeclaration::Initializer *Init : Initializers) {
       switch (Init->getKind()) {
-      case GlobalAddress::Initializer::DataInitializerKind: {
-        const auto Data =
-            llvm::cast<GlobalAddress::DataInitializer>(Init)->getContents();
+      case VariableDeclaration::Initializer::DataInitializerKind: {
+        const auto Data = llvm::cast<VariableDeclaration::DataInitializer>(Init)
+                              ->getContents();
         for (SizeT i = 0; i < Init->getNumBytes(); ++i) {
           Str << "\t.byte\t" << (((unsigned)Data[i]) & 0xff) << "\n";
         }
         break;
       }
-      case GlobalAddress::Initializer::ZeroInitializerKind:
+      case VariableDeclaration::Initializer::ZeroInitializerKind:
         Str << "\t.zero\t" << Init->getNumBytes() << "\n";
         break;
-      case GlobalAddress::Initializer::RelocInitializerKind: {
-        const auto Reloc = llvm::cast<GlobalAddress::RelocInitializer>(Init);
+      case VariableDeclaration::Initializer::RelocInitializerKind: {
+        const auto Reloc =
+            llvm::cast<VariableDeclaration::RelocInitializer>(Init);
         Str << "\t.long\t";
-        // TODO(kschimpf): Once the representation of a relocation has
-        // been modified to reference the corresponding global
-        // address, modify to not mangle the name if the global is
-        // external and uninitialized. This will allow us to better
-        // test cross test relocations.
-        Str << Ctx->mangleName(Reloc->getName());
-        if (GlobalAddress::RelocOffsetType Offset = Reloc->getOffset()) {
-          Str << " + " << Offset;
+        Str << Reloc->getDeclaration()->mangleName(Ctx);
+        if (VariableDeclaration::RelocOffsetType Offset = Reloc->getOffset()) {
+          if (Offset >= 0 || (Offset == INT32_MIN))
+            Str << " + " << Offset;
+          else
+            Str << " - " << -Offset;
         }
         Str << "\n";
         break;
       }
       default: {
         std::string Buffer;
         llvm::raw_string_ostream StrBuf(Buffer);
         StrBuf << "Unable to lower initializer: ";
         Init->dump(StrBuf);
         llvm::report_fatal_error(StrBuf.str());
         break;
       }
       }
     }
   } else if (IsConstant || IsExternal)
     Str << "\t.zero\t" << Size << "\n";
   // Size is part of .comm.
 
   if (IsConstant || HasInitializer || IsExternal)
     Str << "\t.size\t" << MangledName << ", " << Size << "\n";
   // Size is part of .comm.
 }
 
 } // end of namespace Ice