Subzero: Control memory growth from local label fixups.

src/IceFixups.cpp

 //===- subzero/src/IceFixups.cpp - Implementation of Assembler Fixups -----===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief Implements the AssemblerFixup class, a very basic target-independent
 /// representation of a fixup or relocation.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "IceFixups.h"
 
 #include "IceOperand.h"
 
 namespace Ice {
 
 const Constant *AssemblerFixup::NullSymbol = nullptr;
 
 RelocOffsetT AssemblerFixup::offset() const {
   if (isNullSymbol())
     return addend_;
-  if (const auto *CR = llvm::dyn_cast<ConstantRelocatable>(value_))
-    return CR->getOffset() + addend_;
+  if (!ValueIsSymbol) {
+    if (const auto *CR = llvm::dyn_cast<ConstantRelocatable>(ConstValue))
+      return CR->getOffset() + addend_;
+  }
   return addend_;
 }
 
-IceString AssemblerFixup::symbol(const Assembler *Asm) const {
+IceString AssemblerFixup::symbol() const {
+  assert(!isNullSymbol());
+  assert(!ValueIsSymbol);
+  const Constant *C = ConstValue;
+  if (const auto *CR = llvm::dyn_cast<ConstantRelocatable>(C)) {
+    return CR->getName();
+  }
+  // NOTE: currently only float/doubles are put into constant pools. In the
+  // future we may put integers as well.
+  assert(llvm::isa<ConstantFloat>(C) || llvm::isa<ConstantDouble>(C));
   std::string Buffer;
   llvm::raw_string_ostream Str(Buffer);
-  const Constant *C = value_;
-  assert(!isNullSymbol());
-  if (const auto *CR = llvm::dyn_cast<ConstantRelocatable>(C)) {
-    Str << CR->getName();
-    if (Asm && !Asm->fixupIsPCRel(kind()) &&
-        GlobalContext::getFlags().getUseNonsfi() &&
-        CR->getName() != GlobalOffsetTable) {
-      // TODO(jpp): remove the special GOT test.
-      Str << "@GOTOFF";
-    }
-  } else {
-    // NOTE: currently only float/doubles are put into constant pools. In the
-    // future we may put integers as well.
-    assert(llvm::isa<ConstantFloat>(C) || llvm::isa<ConstantDouble>(C));
-    C->emitPoolLabel(Str);
-  }
+  C->emitPoolLabel(Str);
   return Str.str();
 }
 
 size_t AssemblerFixup::emit(GlobalContext *Ctx, const Assembler &Asm) const {
   static constexpr const size_t FixupSize = 4;
   if (!BuildDefs::dump())
     return FixupSize;
   Ostream &Str = Ctx->getStrEmit();
   Str << "\t.long ";
   IceString Symbol;
   if (isNullSymbol()) {
     Str << "__Sz_AbsoluteZero";
   } else {
-    Symbol = symbol(&Asm);
+    Symbol = symbol();
     Str << Symbol;
+    assert(!ValueIsSymbol);
+    if (const auto *CR = llvm::dyn_cast<ConstantRelocatable>(ConstValue)) {
+      if (!Asm.fixupIsPCRel(kind()) &&
+          GlobalContext::getFlags().getUseNonsfi() &&
+          CR->getName() != GlobalOffsetTable) {
+        Str << "@GOTOFF";
+      }
+    }
   }
 
   assert(Asm.load<RelocOffsetT>(position()) == 0);
 
   RelocOffsetT Offset = offset();
   if (Offset != 0) {
     if (Offset > 0) {
       Str << " + " << Offset;
     } else {
       assert(Offset != std::numeric_limits<RelocOffsetT>::lowest());
@@ skipping 13 matching lines @@
 void AssemblerFixup::emitOffset(Assembler *Asm) const {
   Asm->store(position(), offset());
 }
 
 size_t AssemblerTextFixup::emit(GlobalContext *Ctx, const Assembler &) const {
   Ctx->getStrEmit() << Message << "\n";
   return NumBytes;
 }
 
 } // end of namespace Ice