[BOLT] Generate sections for multiple fragments

[FPar]

Summary

This patch adds support to generate any number of sections that are
assigned to fragments of functions that are split more than two-way.
With this, a function's *nth* split fragment goes into section
.text.cold.n.

This also changes FunctionLayout::erase to make sure, that there are
no empty fragments at the end of the function. This sometimes happens
when blocks are erased from the function. To avoid creating symbols
pointing to these fragments, they need to be removed.

[FPar]

Add test case for split-all strategy

[FPar]

Rebase

[FPar]

Don't remove empty fragments when erasing blocks

[FPar]

Trim empty fragments at end and updateOutputValues per fragment

[FPar]

Cleanup

[FPar]

Rebase

[rafauler]

LGTM

bolt/lib/Core/BinaryFunction.cpp

4066

symbol might have not been emitted

[FPar]

Fix comment grammar

bolt/include/bolt/Core/BinaryBasicBlock.h

public:
 
   void setFragmentNum(const FragmentNum Value) { Fragment = Value; }
 
   bool isSplit() const { return Fragment != FragmentNum::main(); }
 
   bool isCold() const {
     assert(Fragment.get() < 2 &&
            "Function is split into more than two (hot/cold)-fragments");
-    return Fragment == FragmentNum::cold();
+    return isSplit();
   }
 
   void setIsCold(const bool Flag) {
     Fragment = Flag ? FragmentNum::cold() : FragmentNum::hot();
   }
 
   /// Return true if the block can be outlined. At the moment we disallow
   /// outlining of blocks that can potentially throw exceptions or are

bolt/include/bolt/Core/BinaryFunction.h

uint32_t getNumNonPseudos() const {
     uint32_t N = 0;
     for (const BinaryBasicBlock &BB : blocks())
       N += BB.getNumNonPseudos();
     return N;
   }
 
   /// Return MC symbol associated with the function.
   /// All references to the function should use this symbol.
-  MCSymbol *getSymbol(const FragmentNum Fragment = FragmentNum::hot()) {
-    if (Fragment == FragmentNum::hot())
+  MCSymbol *getSymbol(const FragmentNum Fragment = FragmentNum::main()) {
+    if (Fragment == FragmentNum::main())
       return Symbols[0];
 
     size_t ColdSymbolIndex = Fragment.get() - 1;
     if (ColdSymbolIndex >= ColdSymbols.size())
       ColdSymbols.resize(ColdSymbolIndex + 1);
 
     MCSymbol *&ColdSymbol = ColdSymbols[ColdSymbolIndex];
     if (ColdSymbol == nullptr) {
public:
   /// Return the name of the section this function originated from.
   Optional<StringRef> getOriginSectionName() const {
     if (!OriginSection)
       return NoneType();
     return OriginSection->getName();
   }
 
   /// Return internal section name for this function.
-  StringRef getCodeSectionName() const { return StringRef(CodeSectionName); }
+  SmallString<32>
+  getCodeSectionName(const FragmentNum Fragment = FragmentNum::main()) const {
+    if (Fragment == FragmentNum::main())
+      return SmallString<32>(CodeSectionName);
+    if (Fragment == FragmentNum::cold())
+      return SmallString<32>(ColdCodeSectionName);
+    return formatv("{0}.{1}", ColdCodeSectionName, Fragment.get() - 1);
+  }
 
   /// Assign a code section name to the function.
-  void setCodeSectionName(StringRef Name) {
-    CodeSectionName = std::string(Name);
+  void setCodeSectionName(const StringRef Name) {
+    CodeSectionName = Name.str();
   }
 
   /// Get output code section.
-  ErrorOr<BinarySection &> getCodeSection() const {
-    return BC.getUniqueSectionByName(getCodeSectionName());
-  }
-
-  /// Return cold code section name for the function.
-  std::string getColdCodeSectionName(FragmentNum Fragment) const {
-    std::string Result = ColdCodeSectionName;
-    if (Fragment != FragmentNum::cold())
-      Result.append(".").append(std::to_string(Fragment.get() - 1));
-    return Result;
+  ErrorOr<BinarySection &>
+  getCodeSection(const FragmentNum Fragment = FragmentNum::main()) const {
+    return BC.getUniqueSectionByName(getCodeSectionName(Fragment));
   }
 
   /// Assign a section name for the cold part of the function.
   void setColdCodeSectionName(StringRef Name) {
-    ColdCodeSectionName = std::string(Name);
-  }
-
-  /// Get output code section for cold code of this function.
-  ErrorOr<BinarySection &> getColdCodeSection(FragmentNum Fragment) const {
-    return BC.getUniqueSectionByName(getColdCodeSectionName(Fragment));
+    ColdCodeSectionName = Name.str();
   }
 
   /// Return true iif the function will halt execution on entry.
   bool trapsOnEntry() const { return TrapsOnEntry; }
 
   /// Make the function always trap on entry. Other than the trap instruction,
   /// the function body will be empty.
   void setTrapOnEntry();

 
   /// Return symbol pointing to function's LSDA for the cold part.
   MCSymbol *getColdLSDASymbol(const FragmentNum Fragment) {
     if (ColdLSDASymbol)
       return ColdLSDASymbol;
     if (ColdCallSites.empty())
       return nullptr;
 
-    SmallString<8> SymbolSuffix;
-    if (Fragment != FragmentNum::cold())
-      SymbolSuffix = formatv(".{0}", Fragment.get());
-    ColdLSDASymbol = BC.Ctx->getOrCreateSymbol(formatv(
-        "GCC_cold_except_table{0:x-}{1}", getFunctionNumber(), SymbolSuffix));
+    ColdLSDASymbol =
+        BC.Ctx->getOrCreateSymbol(formatv("GCC_cold_except_table{0:x-}.{1}",
+                                          getFunctionNumber(), Fragment.get()));
 
     return ColdLSDASymbol;
   }
 
   void setOutputDataAddress(uint64_t Address) { OutputDataOffset = Address; }
 
   uint64_t getOutputDataAddress() const { return OutputDataOffset; }
 

bolt/include/bolt/Core/FunctionLayout.h

public:
   FunctionFragment addFragment();
 
   /// Return the fragment identified by Num.
   FunctionFragment getFragment(FragmentNum Num) const;
 
   /// Get the fragment that contains all entry blocks and other blocks that
   /// cannot be split.
   FunctionFragment getMainFragment() const {
-    return getFragment(FragmentNum::hot());
+    return getFragment(FragmentNum::main());
   }
 
   /// Get the fragment that contains all entry blocks and other blocks that
   /// cannot be split.
   iterator_range<const_iterator> getSplitFragments() const {
     return {++fragment_begin(), fragment_end()};
   }
 
   /// Find the fragment that contains BB.
   FunctionFragment findFragment(const BinaryBasicBlock *BB) const;
 
   /// Add BB to the end of the last fragment.
   void addBasicBlock(BinaryBasicBlock *BB);
 
   /// Insert range of basic blocks after InsertAfter. If InsertAfter is nullptr,
   /// the blocks will be inserted at the start of the function.
   void insertBasicBlocks(BinaryBasicBlock *InsertAfter,
                          ArrayRef<BinaryBasicBlock *> NewBlocks);
 
-  /// Erase all blocks from the layout that are in ToErase.
+  /// Erase all blocks from the layout that are in ToErase. If this method
+  /// erases all blocks of a fragment, it will be removed as well.
   void eraseBasicBlocks(const DenseSet<const BinaryBasicBlock *> ToErase);
 
   /// Make sure fragments' and basic blocks' indices match the current layout.
   void updateLayoutIndices() const;
 
   /// Replace the current layout with NewLayout. Uses the block's
   /// self-identifying fragment number to assign blocks to infer function
   /// fragments.

bolt/lib/Core/BinaryContext.cpp

BinaryContext::calculateEmittedSize(BinaryFunction &BF, bool FixBranches) {
 
   for (const FunctionFragment F : BF.getLayout().getSplitFragments()) {
     MCSymbol *const FragStartLabel = LocalCtx->createTempSymbol();
     MCSymbol *const FragEndLabel = LocalCtx->createTempSymbol();
     ColdStartEndLabels.emplace_back(FragStartLabel, FragEndLabel);
 
     Streamer->emitLabel(FragStartLabel);
     MCSectionELF *const ColdSection = LocalCtx->getELFSection(
-        BF.getColdCodeSectionName(F.getFragmentNum()), ELF::SHT_PROGBITS,
+        BF.getCodeSectionName(F.getFragmentNum()), ELF::SHT_PROGBITS,
         ELF::SHF_EXECINSTR | ELF::SHF_ALLOC);
     ColdSection->setHasInstructions(true);
 
     Streamer->switchSection(ColdSection);
     emitFunctionBody(*Streamer, BF, F, /*EmitCodeOnly=*/true);
     Streamer->emitLabel(FragEndLabel);
     // To avoid calling MCObjectStreamer::flushPendingLabels() which is
     // private

bolt/lib/Core/BinaryEmitter.cpp

 bool BinaryEmitter::emitFunction(BinaryFunction &Function,
                                  const FunctionFragment &F) {
   if (Function.size() == 0 && !Function.hasIslandsInfo())
     return false;
 
   if (Function.getState() == BinaryFunction::State::Empty)
     return false;
 
-  MCSection *Section = BC.getCodeSection(
-      F.isSplitFragment() ? Function.getColdCodeSectionName(F.getFragmentNum())
-                          : Function.getCodeSectionName());
+  MCSection *Section =
+      BC.getCodeSection(Function.getCodeSectionName(F.getFragmentNum()));
   Streamer.switchSection(Section);
   Section->setHasInstructions(true);
   BC.Ctx->addGenDwarfSection(Section);
 
   if (BC.HasRelocations) {
     // Set section alignment to at least maximum possible object alignment.
     // We need this to support LongJmp and other passes that calculates
     // tentative layout.
bool BinaryEmitter::emitFunction(BinaryFunction &Function,
 
   return true;
 }
 
 void BinaryEmitter::emitFunctionBody(BinaryFunction &BF,
                                      const FunctionFragment &F,
                                      bool EmitCodeOnly) {
   if (!EmitCodeOnly && F.isSplitFragment() && BF.hasConstantIsland()) {
-    assert(F.getFragmentNum() == FragmentNum::cold() &&
+    assert(BF.getLayout().isHotColdSplit() &&
            "Constant island support only with hot/cold split");
     BF.duplicateConstantIslands();
   }
 
   // Track the first emitted instruction with debug info.
   bool FirstInstr = true;
   for (BinaryBasicBlock *const BB : F) {
     if ((opts::AlignBlocks || opts::PreserveBlocksAlignment) &&
void BinaryEmitter::emitLSDA(BinaryFunction &BF, bool EmitColdPart) {
   MCSymbol *LSDASymbol = EmitColdPart
                              ? BF.getColdLSDASymbol(FragmentNum::cold())
                              : BF.getLSDASymbol();
   assert(LSDASymbol && "no LSDA symbol set");
   Streamer.emitLabel(LSDASymbol);
 
   // Corresponding FDE start.
   const MCSymbol *StartSymbol =
-      EmitColdPart ? BF.getSymbol(FragmentNum::cold()) : BF.getSymbol();
+      BF.getSymbol(EmitColdPart ? FragmentNum::cold() : FragmentNum::main());
 
   // Emit the LSDA header.
 
   // If LPStart is omitted, then the start of the FDE is used as a base for
   // landing pad displacements. Then if a cold fragment starts with
   // a landing pad, this means that the first landing pad offset will be 0.
   // As a result, the exception handling runtime will ignore this landing pad
   // because zero offset denotes the absence of a landing pad.

bolt/lib/Core/BinaryFunction.cpp

void BinaryFunction::updateOutputValues(const MCAsmLayout &Layout) {
   if (!isEmitted()) {
     assert(!isInjected() && "injected function should be emitted");
     setOutputAddress(getAddress());
     setOutputSize(getSize());
     return;
   }
 
   const uint64_t BaseAddress = getCodeSection()->getOutputAddress();
-  ErrorOr<BinarySection &> ColdSection =
-      getColdCodeSection(FragmentNum::cold());
-  const uint64_t ColdBaseAddress =
-      isSplit() ? ColdSection->getOutputAddress() : 0;
   if (BC.HasRelocations || isInjected()) {
     const uint64_t StartOffset = Layout.getSymbolOffset(*getSymbol());
     const uint64_t EndOffset = Layout.getSymbolOffset(*getFunctionEndLabel());
     setOutputAddress(BaseAddress + StartOffset);
     setOutputSize(EndOffset - StartOffset);
     if (hasConstantIsland()) {
       const uint64_t DataOffset =
           Layout.getSymbolOffset(*getFunctionConstantIslandLabel());
       setOutputDataAddress(BaseAddress + DataOffset);
     }
     if (isSplit()) {
-      const MCSymbol *ColdStartSymbol = getSymbol(FragmentNum::cold());
+      for (const FunctionFragment F : getLayout().getSplitFragments()) {
+        ErrorOr<BinarySection &> ColdSection =
+            getCodeSection(F.getFragmentNum());
+        const uint64_t ColdBaseAddress = ColdSection->getOutputAddress();
+
+        const MCSymbol *ColdStartSymbol = getSymbol(F.getFragmentNum());
         assert(ColdStartSymbol && ColdStartSymbol->isDefined() &&
                "split function should have defined cold symbol");
-      const MCSymbol *ColdEndSymbol = getFunctionEndLabel(FragmentNum::cold());
+        const MCSymbol *ColdEndSymbol = getFunctionEndLabel(F.getFragmentNum());
         assert(ColdEndSymbol && ColdEndSymbol->isDefined() &&
                "split function should have defined cold end symbol");
-      const uint64_t ColdStartOffset = Layout.getSymbolOffset(*ColdStartSymbol);
+        const uint64_t ColdStartOffset =
+            Layout.getSymbolOffset(*ColdStartSymbol);
         const uint64_t ColdEndOffset = Layout.getSymbolOffset(*ColdEndSymbol);
         cold().setAddress(ColdBaseAddress + ColdStartOffset);
         cold().setImageSize(ColdEndOffset - ColdStartOffset);
         if (hasConstantIsland()) {
           const uint64_t DataOffset =
               Layout.getSymbolOffset(*getFunctionColdConstantIslandLabel());
           setOutputColdDataAddress(ColdBaseAddress + DataOffset);
         }
       }
+    }
   } else {
     setOutputAddress(getAddress());
     setOutputSize(Layout.getSymbolOffset(*getFunctionEndLabel()));
   }
 
   // Update basic block output ranges for the debug info, if we have
   // secondary entry points in the symbol table to update or if writing BAT.
   if (!opts::UpdateDebugSections && !isMultiEntry() &&
       !requiresAddressTranslation())
     return;
 
   // Output ranges should match the input if the body hasn't changed.
   if (!isSimple() && !BC.HasRelocations)
     return;
 
   // AArch64 may have functions that only contains a constant island (no code).
   if (getLayout().block_empty())
     return;
 
   BinaryBasicBlock *PrevBB = nullptr;
-  for (BinaryBasicBlock *BB : this->Layout.blocks()) {
+  for (const FunctionFragment F : getLayout().fragments()) {
+    uint64_t ColdBaseAddress = 0;
+    if (isSimple() && F.isSplitFragment()) {
+      ErrorOr<BinarySection &> ColdSection = getCodeSection(F.getFragmentNum());
+      ColdBaseAddress = ColdSection->getOutputAddress();
+    }
+
+    for (BinaryBasicBlock *const BB : F) {
       assert(BB->getLabel()->isDefined() && "symbol should be defined");
-    const uint64_t BBBaseAddress = BB->isCold() ? ColdBaseAddress : BaseAddress;
+      const uint64_t BBBaseAddress =
+          BB->isCold() ? ColdBaseAddress : BaseAddress;
       if (!BC.HasRelocations) {
         if (BB->isCold()) {
           assert(BBBaseAddress == cold().getAddress());
         } else {
           assert(BBBaseAddress == getOutputAddress());
         }
       }
       const uint64_t BBOffset = Layout.getSymbolOffset(*BB->getLabel());
       const uint64_t BBAddress = BBBaseAddress + BBOffset;
       BB->setOutputStartAddress(BBAddress);
 
       if (PrevBB) {
         uint64_t PrevBBEndAddress = BBAddress;
         if (BB->isCold() != PrevBB->isCold())
           PrevBBEndAddress = getOutputAddress() + getOutputSize();
         PrevBB->setOutputEndAddress(PrevBBEndAddress);
       }
       PrevBB = BB;
 
       BB->updateOutputValues(Layout);
     }
+  }
   PrevBB->setOutputEndAddress(PrevBB->isCold()
                                   ? cold().getAddress() + cold().getImageSize()
                                   : getOutputAddress() + getOutputSize());
 }
 
 DebugAddressRangesVector BinaryFunction::getOutputAddressRanges() const {
   DebugAddressRangesVector OutputRanges;
 

bolt/lib/Core/FunctionLayout.cpp

void FunctionLayout::eraseBasicBlocks(
     const DenseSet<const BinaryBasicBlock *> ToErase) {
   auto IsErased = [&](const BinaryBasicBlock *const BB) {
     return ToErase.contains(BB);
   };
   FragmentListType NewFragments;
   NewFragments.emplace_back(0);
   for (const FunctionFragment F : fragments()) {
     unsigned ErasedBlocks = count_if(F, IsErased);
+    // Only add the fragment if it is non-empty after removing blocks.
+    if (ErasedBlocks < F.size()) {
       unsigned NewFragment = NewFragments.back() + F.size() - ErasedBlocks;
       NewFragments.emplace_back(NewFragment);
+    } else {
+      assert(!F.isMainFragment() && "Main fragment should not be empty when "
+                                    "there are other blocks in the layout.");
+    }
   }
   Blocks.erase(std::remove_if(Blocks.begin(), Blocks.end(), IsErased),
                Blocks.end());
   Fragments = std::move(NewFragments);
+  updateLayoutIndices();
 }
 
 void FunctionLayout::updateLayoutIndices() const {
   unsigned BlockIndex = 0;
   for (const FunctionFragment F : fragments()) {
-    for (BinaryBasicBlock *const BB : F)
+    for (BinaryBasicBlock *const BB : F) {
       BB->setLayoutIndex(BlockIndex++);
+      BB->setFragmentNum(F.getFragmentNum());
+    }
   }
 }
 
 void FunctionLayout::update(const ArrayRef<BinaryBasicBlock *> NewLayout) {
   PreviousBlocks = std::move(Blocks);
   PreviousFragments = std::move(Fragments);
 
   Blocks.clear();

bolt/lib/Passes/SplitFunctions.cpp

if (alignTo(OriginalHotSize, opts::SplitAlignThreshold) <=
 
       // Reverse the action of createEHTrampolines(). The trampolines will be
       // placed immediately before the matching destination resulting in no
       // extra code.
       if (PreSplitLayout.size() != BF.size())
         PreSplitLayout = mergeEHTrampolines(BF, PreSplitLayout, Trampolines);
 
       for (BinaryBasicBlock &BB : BF)
-        BB.setFragmentNum(FragmentNum::hot());
+        BB.setFragmentNum(FragmentNum::main());
       BF.getLayout().update(PreSplitLayout);
     } else {
       SplitBytesHot += HotSize;
       SplitBytesCold += ColdSize;
     }
   }
 }
 

bolt/lib/Rewrite/RewriteInstance.cpp

for (BinaryFunction *Function : BC->getAllBinaryFunctions()) {
     // Restore origin section for functions that were emitted or supposed to
     // be emitted to patch sections.
     if (Section)
       BC->deregisterSection(*Section);
     assert(Function->getOriginSectionName() && "expected origin section");
     Function->CodeSectionName = std::string(*Function->getOriginSectionName());
     for (const FunctionFragment F : Function->getLayout().getSplitFragments()) {
       if (ErrorOr<BinarySection &> ColdSection =
-              Function->getColdCodeSection(F.getFragmentNum()))
+              Function->getCodeSection(F.getFragmentNum()))
         BC->deregisterSection(*ColdSection);
-      Function->ColdCodeSectionName = std::string(getBOLTTextSectionName());
+      Function->setColdCodeSectionName(getBOLTTextSectionName());
     }
   }
 
   if (opts::PrintCacheMetrics) {
     outs() << "BOLT-INFO: cache metrics after emitting functions:\n";
     CacheMetrics::printAll(BC->getSortedFunctions());
   }
 
if (opts::JumpTables == JTS_BASIC) {
       }
     }
 
     if (!Function.isSplit())
       continue;
 
     for (const FunctionFragment F : Function.getLayout().getSplitFragments()) {
       ErrorOr<BinarySection &> ColdSection =
-          Function.getColdCodeSection(F.getFragmentNum());
+          Function.getCodeSection(F.getFragmentNum());
       assert(ColdSection && "cannot find section for cold part");
       // Cold fragments are aligned at 16 bytes.
       NextAvailableAddress = alignTo(NextAvailableAddress, 16);
       BinaryFunction::FragmentInfo &ColdPart = Function.cold();
       if (TooLarge) {
         // The corresponding FDE will refer to address 0.
         ColdPart.setAddress(0);
         ColdPart.setImageAddress(0);
if (Function.isFolded()) {
                           .concat(".icf.0")
                           .toStringRef(Buf));
       ICFSymbol.st_value = ICFParent->getOutputAddress();
       ICFSymbol.st_size = ICFParent->getOutputSize();
       ICFSymbol.st_shndx = ICFParent->getCodeSection()->getIndex();
       Symbols.emplace_back(ICFSymbol);
     }
     if (Function.isSplit() && Function.cold().getAddress()) {
-      assert(Function.getLayout().isHotColdSplit());
+      for (const FunctionFragment F :
+           Function.getLayout().getSplitFragments()) {
         ELFSymTy NewColdSym = FunctionSymbol;
-      SmallVector<char, 256> Buf;
-      NewColdSym.st_name =
-          AddToStrTab(Twine(cantFail(FunctionSymbol.getName(StringSection)))
-                          .concat(".cold.0")
-                          .toStringRef(Buf));
+        SmallString<256> SymbolName = formatv(
+            "{0}.cold.{1}", cantFail(FunctionSymbol.getName(StringSection)),
+            F.getFragmentNum().get() - 1);
+        NewColdSym.st_name = AddToStrTab(SymbolName);
         NewColdSym.st_shndx =
-          Function.getColdCodeSection(FragmentNum::cold())->getIndex();
+            Function.getCodeSection(F.getFragmentNum())->getIndex();
         NewColdSym.st_value = Function.cold().getAddress();
         NewColdSym.st_size = Function.cold().getImageSize();
         NewColdSym.setBindingAndType(ELF::STB_LOCAL, ELF::STT_FUNC);
         Symbols.emplace_back(NewColdSym);
       }
+    }
     if (Function.hasConstantIsland()) {
       uint64_t DataMark = Function.getOutputDataAddress();
       uint64_t CISize = getConstantIslandSize(Function);
       uint64_t CodeMark = DataMark + CISize;
       ELFSymTy DataMarkSym = FunctionSymbol;
       DataMarkSym.st_name = AddToStrTab("$d");
       DataMarkSym.st_value = DataMark;
       DataMarkSym.st_size = 0;
if (Function) {
             Function->translateInputToOutputAddress(Symbol.st_value);
 
         NewSymbol.st_value = OutputAddress;
         // Force secondary entry points to have zero size.
         NewSymbol.st_size = 0;
         NewSymbol.st_shndx =
             OutputAddress >= Function->cold().getAddress() &&
                     OutputAddress < Function->cold().getImageSize()
-                ? Function->getColdCodeSection(FragmentNum::cold())->getIndex()
+                ? Function->getCodeSection(FragmentNum::cold())->getIndex()
                 : Function->getCodeSection()->getIndex();
       } else {
         // Check if the symbol belongs to moved data object and update it.
         BinaryData *BD = opts::ReorderData.empty()
                              ? nullptr
                              : BC->getBinaryDataAtAddress(Symbol.st_value);
         if (BD && BD->isMoved() && !BD->isJumpTable()) {
           assert((!BD->getSize() || !Symbol.st_size ||
for (BinaryFunction *Function : BC->getInjectedBinaryFunctions()) {
     NewSymbol.st_value = Function->getOutputAddress();
     NewSymbol.st_name = AddToStrTab(Function->getOneName());
     NewSymbol.st_size = Function->getOutputSize();
     NewSymbol.st_other = 0;
     NewSymbol.setBindingAndType(ELF::STB_LOCAL, ELF::STT_FUNC);
     Symbols.emplace_back(NewSymbol);
 
     if (Function->isSplit()) {
+      assert(Function->getLayout().isHotColdSplit());
       ELFSymTy NewColdSym = NewSymbol;
       NewColdSym.setType(ELF::STT_NOTYPE);
       SmallVector<char, 256> Buf;
       NewColdSym.st_name = AddToStrTab(
           Twine(Function->getPrintName()).concat(".cold.0").toStringRef(Buf));
       NewColdSym.st_value = Function->cold().getAddress();
       NewColdSym.st_size = Function->cold().getImageSize();
       Symbols.emplace_back(NewColdSym);