Fix timing of parseFunctions.

src/IceELFObjectWriter.cpp

 //===- subzero/src/IceELFObjectWriter.cpp - ELF object file writer --------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 201 matching lines @@
   if (AlignDiff == 0)
     return OffsetInFile;
   Str.writeZeroPadding(AlignDiff);
   OffsetInFile += AlignDiff;
   return OffsetInFile;
 }
 
 void ELFObjectWriter::writeFunctionCode(const IceString &FuncName,
                                         bool IsInternal, Assembler *Asm) {
   assert(!SectionNumbersAssigned);
+  TimerMarker Timer(TimerStack::TT_writeELF, &Ctx);
+  constexpr TimerStackIdT StackID = GlobalContext::TSK_Funcs;
+  TimerIdT TimerID = 0;
+  bool TimeThisFunction = Ctx.getFlags().getTimeEachFunction();
+  if (TimeThisFunction) {
+    TimerID = Ctx.getTimerID(StackID, FuncName);
+    Ctx.pushTimer(TimerID, StackID);
+  }
   ELFTextSection *Section = nullptr;
   ELFRelocationSection *RelSection = nullptr;
   const bool FunctionSections = Ctx.getFlags().getFunctionSections();
   if (TextSections.empty() || FunctionSections) {
     IceString SectionName = ".text";
     if (FunctionSections)
       SectionName += "." + FuncName;
     constexpr Elf64_Xword ShFlags = SHF_ALLOC | SHF_EXECINSTR;
     const Elf64_Xword ShAlign = 1 << Asm->getBundleAlignLog2Bytes();
     Section = createSection<ELFTextSection>(SectionName, SHT_PROGBITS, ShFlags,
@@ skipping 31 matching lines @@
     if (!RelSection->isRela()) {
       // This is a non-rela section, so we need to update the instruction stream
       // with the relocation addends.
       for (const auto *Fixup : Fixups) {
         Fixup->emitOffset(Asm);
       }
     }
     RelSection->addRelocations(OffsetInSection, Asm->fixups());
   }
   Section->appendData(Str, Asm->getBufferView());
+  if (TimeThisFunction)
+    Ctx.popTimer(TimerID, StackID);
 }
 
 namespace {
 
 ELFObjectWriter::SectionType
 classifyGlobalSection(const VariableDeclaration *Var) {
   if (Var->getIsConstant())
     return ELFObjectWriter::ROData;
   if (Var->hasNonzeroInitializer())
     return ELFObjectWriter::Data;
@@ skipping 13 matching lines @@
     }
   }
 }
 
 } // end of anonymous namespace
 
 void ELFObjectWriter::writeDataSection(const VariableDeclarationList &Vars,
                                        FixupKind RelocationKind,
                                        const IceString &SectionSuffix,
                                        bool IsPIC) {
+  TimerMarker Timer(TimerStack::TT_writeELF, &Ctx);
   assert(!SectionNumbersAssigned);
   VariableDeclarationList VarsBySection[ELFObjectWriter::NumSectionTypes];
   for (auto &SectionList : VarsBySection)
     SectionList.reserve(Vars.size());
   partitionGlobalsBySection(Vars, VarsBySection,
                             Ctx.getFlags().getTranslateOnly());
   size_t I = 0;
   for (auto &SectionList : VarsBySection) {
     writeDataOfType(static_cast<SectionType>(I++), SectionList, RelocationKind,
                     SectionSuffix, IsPIC);
@@ skipping 116 matching lines @@
                                           Reloc->getOffset());
           break;
         }
         }
       }
     }
   }
 }
 
 void ELFObjectWriter::writeInitialELFHeader() {
+  TimerMarker Timer(TimerStack::TT_writeELF, &Ctx);
   assert(!SectionNumbersAssigned);
   constexpr Elf64_Off DummySHOffset = 0;
   constexpr SizeT DummySHStrIndex = 0;
   constexpr SizeT DummyNumSections = 0;
   if (ELF64) {
     writeELFHeaderInternal<true>(DummySHOffset, DummySHStrIndex,
                                  DummyNumSections);
   } else {
     writeELFHeaderInternal<false>(DummySHOffset, DummySHStrIndex,
                                   DummyNumSections);
@@ skipping 41 matching lines @@
   Str.writeLE16(0); // e_phnum
   Str.writeLE16(IsELF64 ? sizeof(Elf64_Shdr)
                         : sizeof(Elf32_Shdr)); // e_shentsize
   static_assert(sizeof(Elf64_Shdr) == 64 && sizeof(Elf32_Shdr) == 40,
                 "Elf_Shdr sizes cannot be derived from sizeof");
   Str.writeLE16(static_cast<Elf64_Half>(NumSections));        // e_shnum
   Str.writeLE16(static_cast<Elf64_Half>(SectHeaderStrIndex)); // e_shstrndx
 }
 
 template <typename ConstType> void ELFObjectWriter::writeConstantPool(Type Ty) {
+  TimerMarker Timer(TimerStack::TT_writeELF, &Ctx);
   ConstantList Pool = Ctx.getConstantPool(Ty);
   if (Pool.empty()) {
     return;
   }
   SizeT Align = typeAlignInBytes(Ty);
   size_t EntSize = typeWidthInBytes(Ty);
   char Buf[20];
   SizeT WriteAmt = std::min(EntSize, llvm::array_lengthof(Buf));
   // Check that we write the full PrimType.
   assert(WriteAmt == EntSize);
@@ skipping 56 matching lines @@
 template void ELFObjectWriter::writeConstantPool<ConstantInteger32>(Type Ty);
 
 void ELFObjectWriter::writeAllRelocationSections() {
   writeRelocationSections(RelTextSections);
   writeRelocationSections(RelDataSections);
   writeRelocationSections(RelRODataSections);
 }
 
 void ELFObjectWriter::writeJumpTable(const JumpTableData &JT,
                                      FixupKind RelocationKind, bool IsPIC) {
+  TimerMarker Timer(TimerStack::TT_writeELF, &Ctx);
   ELFDataSection *Section;
   ELFRelocationSection *RelSection;
   const Elf64_Xword PointerSize = typeWidthInBytes(getPointerType());
   const Elf64_Xword ShAddralign = PointerSize;
   const Elf64_Xword ShEntsize = PointerSize;
   const IceString SectionName = MangleSectionName(
       IsPIC ? ".data.rel.ro" : ".rodata", JT.getFunctionName() + "$jumptable");
   Section = createSection<ELFDataSection>(SectionName, SHT_PROGBITS, SHF_ALLOC,
                                           ShAddralign, ShEntsize);
   Section->setFileOffset(alignFileOffset(ShAddralign));
@@ skipping 15 matching lines @@
     AssemblerFixup NewFixup;
     NewFixup.set_position(Section->getCurrentSize());
     NewFixup.set_kind(RelocationKind);
     NewFixup.set_value(Ctx.getConstantSym(TargetOffset, JT.getFunctionName()));
     RelSection->addRelocation(NewFixup);
     Section->appendRelocationOffset(Str, RelSection->isRela(), TargetOffset);
   }
 }
 
 void ELFObjectWriter::setUndefinedSyms(const ConstantList &UndefSyms) {
+  TimerMarker Timer(TimerStack::TT_writeELF, &Ctx);
   for (const Constant *S : UndefSyms) {
     const auto *Sym = llvm::cast<ConstantRelocatable>(S);
     const IceString &Name = Sym->getName();
     bool BadIntrinsic;
     const Intrinsics::FullIntrinsicInfo *Info =
         Ctx.getIntrinsicsInfo().find(Name, BadIntrinsic);
     if (Info)
       continue;
     // Ignore BadIntrinsic, which is set if the name begins with "llvm." but
     // doesn't match a known intrinsic.  If we want this to turn into an error,
@@ skipping 11 matching lines @@
     RelSec->setSize(RelSec->getSectionDataSize());
     if (ELF64) {
       RelSec->writeData<true>(Str, SymTab);
     } else {
       RelSec->writeData<false>(Str, SymTab);
     }
   }
 }
 
 void ELFObjectWriter::writeNonUserSections() {
+  TimerMarker Timer(TimerStack::TT_writeELF, &Ctx);
+
   // Write out the shstrtab now that all sections are known.
   ShStrTab->doLayout();
   ShStrTab->setSize(ShStrTab->getSectionDataSize());
   Elf64_Off ShStrTabOffset = alignFileOffset(ShStrTab->getSectionAlign());
   ShStrTab->setFileOffset(ShStrTabOffset);
   Str.writeBytes(ShStrTab->getSectionData());
 
   SectionList AllSections;
   assignSectionNumbersInfo(AllSections);
 
@@ skipping 29 matching lines @@
   if (ELF64) {
     writeELFHeaderInternal<true>(ShOffset, ShStrTab->getNumber(),
                                  AllSections.size());
   } else {
     writeELFHeaderInternal<false>(ShOffset, ShStrTab->getNumber(),
                                   AllSections.size());
   }
 }
 
 } // end of namespace Ice