Reflow comments to use the full width.

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 87 matching lines @@
                                   Elf64_Xword ShEntsize) {
   assert(!SectionNumbersAssigned);
   T *NewSection =
       new (Ctx.allocate<T>()) T(Name, ShType, ShFlags, ShAddralign, ShEntsize);
   ShStrTab->add(Name);
   return NewSection;
 }
 
 ELFRelocationSection *
 ELFObjectWriter::createRelocationSection(const ELFSection *RelatedSection) {
-  // Choice of RELA vs REL is actually separate from elf64 vs elf32,
-  // but in practice we've only had .rela for elf64 (x86-64).
-  // In the future, the two properties may need to be decoupled
-  // and the ShEntSize can vary more.
+  // Choice of RELA vs REL is actually separate from elf64 vs elf32, but in
+  // practice we've only had .rela for elf64 (x86-64). In the future, the two
+  // properties may need to be decoupled and the ShEntSize can vary more.
   const Elf64_Word ShType = ELF64 ? SHT_RELA : SHT_REL;
   IceString RelPrefix = ELF64 ? ".rela" : ".rel";
   IceString RelSectionName = RelPrefix + RelatedSection->getName();
   const Elf64_Xword ShAlign = ELF64 ? 8 : 4;
   const Elf64_Xword ShEntSize = ELF64 ? sizeof(Elf64_Rela) : sizeof(Elf32_Rel);
   static_assert(sizeof(Elf64_Rela) == 24 && sizeof(Elf32_Rel) == 8,
                 "Elf_Rel/Rela sizes cannot be derived from sizeof");
   const Elf64_Xword ShFlags = 0;
   ELFRelocationSection *RelSection = createSection<ELFRelocationSection>(
       RelSectionName, ShType, ShFlags, ShAlign, ShEntSize);
@@ skipping 29 matching lines @@
 }
 
 void ELFObjectWriter::assignRelLinkNum(SizeT SymTabNumber,
                                        RelSectionList &RelSections) {
   for (ELFRelocationSection *S : RelSections) {
     S->setLinkNum(SymTabNumber);
   }
 }
 
 void ELFObjectWriter::assignSectionNumbersInfo(SectionList &AllSections) {
-  // Go through each section, assigning them section numbers and
-  // and fill in the size for sections that aren't incrementally updated.
+  // Go through each section, assigning them section numbers and and fill in
+  // the size for sections that aren't incrementally updated.
   assert(!SectionNumbersAssigned);
   SizeT CurSectionNumber = 0;
   NullSection->setNumber(CurSectionNumber++);
   // The rest of the fields are initialized to 0, and stay that way.
   AllSections.push_back(NullSection);
 
   assignRelSectionNumInPairs<TextSectionList>(CurSectionNumber, TextSections,
                                               RelTextSections, AllSections);
   assignRelSectionNumInPairs<DataSectionList>(CurSectionNumber, DataSections,
                                               RelDataSections, AllSections);
@@ skipping 53 matching lines @@
     Elf64_Off OffsetInFile = alignFileOffset(Section->getSectionAlign());
     Section->setFileOffset(OffsetInFile);
     TextSections.push_back(Section);
     RelSection = createRelocationSection(Section);
     RelTextSections.push_back(RelSection);
   } else {
     Section = TextSections[0];
     RelSection = RelTextSections[0];
   }
   RelocOffsetT OffsetInSection = Section->getCurrentSize();
-  // Function symbols are set to 0 size in the symbol table,
-  // in contrast to data symbols which have a proper size.
+  // Function symbols are set to 0 size in the symbol table, in contrast to
+  // data symbols which have a proper size.
   SizeT SymbolSize = 0;
   Section->appendData(Str, Asm->getBufferView());
   uint8_t SymbolType;
   uint8_t SymbolBinding;
   if (IsInternal && !Ctx.getFlags().getDisableInternal()) {
     SymbolType = STT_NOTYPE;
     SymbolBinding = STB_LOCAL;
   } else {
     SymbolType = STT_FUNC;
     SymbolBinding = STB_GLOBAL;
@@ skipping 13 matching lines @@
 
 ELFObjectWriter::SectionType
 classifyGlobalSection(const VariableDeclaration *Var) {
   if (Var->getIsConstant())
     return ELFObjectWriter::ROData;
   if (Var->hasNonzeroInitializer())
     return ELFObjectWriter::Data;
   return ELFObjectWriter::BSS;
 }
 
-// Partition the Vars list by SectionType into VarsBySection.
-// If TranslateOnly is non-empty, then only the TranslateOnly variable
-// is kept for emission.
+// Partition the Vars list by SectionType into VarsBySection. If TranslateOnly
+// is non-empty, then only the TranslateOnly variable is kept for emission.
 void partitionGlobalsBySection(const VariableDeclarationList &Vars,
                                VariableDeclarationList VarsBySection[],
                                const IceString &TranslateOnly) {
   for (VariableDeclaration *Var : Vars) {
     if (GlobalContext::matchSymbolName(Var->getName(), TranslateOnly)) {
       size_t Section = classifyGlobalSection(Var);
       assert(Section < ELFObjectWriter::NumSectionTypes);
       VarsBySection[Section].push_back(Var);
     }
   }
@@ skipping 149 matching lines @@
   } else {
     writeELFHeaderInternal<false>(DummySHOffset, DummySHStrIndex,
                                   DummyNumSections);
   }
 }
 
 template <bool IsELF64>
 void ELFObjectWriter::writeELFHeaderInternal(Elf64_Off SectionHeaderOffset,
                                              SizeT SectHeaderStrIndex,
                                              SizeT NumSections) {
-  // Write the e_ident: magic number, class, etc.
-  // The e_ident is byte order and ELF class independent.
+  // Write the e_ident: magic number, class, etc. The e_ident is byte order and
+  // ELF class independent.
   Str.writeBytes(llvm::StringRef(ElfMagic, strlen(ElfMagic)));
   Str.write8(IsELF64 ? ELFCLASS64 : ELFCLASS32);
   Str.write8(ELFDATA2LSB);
   Str.write8(EV_CURRENT);
   Str.write8(ELFOSABI_NONE);
   const uint8_t ELF_ABIVersion = 0;
   Str.write8(ELF_ABIVersion);
   Str.writeZeroPadding(EI_NIDENT - EI_PAD);
 
-  // TODO(jvoung): Handle and test > 64K sections.  See the generic ABI doc:
-  // https://refspecs.linuxbase.org/elf/gabi4+/ch4.eheader.html
-  // e_shnum should be 0 and then actual number of sections is
-  // stored in the sh_size member of the 0th section.
+  // TODO(jvoung): Handle and test > 64K sections. See the generic ABI doc:
+  // https://refspecs.linuxbase.org/elf/gabi4+/ch4.eheader.html e_shnum should
+  // be 0 and then actual number of sections is stored in the sh_size member of
+  // the 0th section.
   assert(NumSections < SHN_LORESERVE);
   assert(SectHeaderStrIndex < SHN_LORESERVE);
 
   const TargetArch Arch = Ctx.getFlags().getTargetArch();
-  // Write the rest of the file header, which does depend on byte order
-  // and ELF class.
+  // Write the rest of the file header, which does depend on byte order and ELF
+  // class.
   Str.writeLE16(ET_REL);                                        // e_type
   Str.writeLE16(getELFMachine(Ctx.getFlags().getTargetArch())); // e_machine
   Str.writeELFWord<IsELF64>(1);                                 // e_version
-  // Since this is for a relocatable object, there is no entry point,
-  // and no program headers.
+  // Since this is for a relocatable object, there is no entry point, and no
+  // program headers.
   Str.writeAddrOrOffset<IsELF64>(0);                                // e_entry
   Str.writeAddrOrOffset<IsELF64>(0);                                // e_phoff
   Str.writeAddrOrOffset<IsELF64>(SectionHeaderOffset);              // e_shoff
   Str.writeELFWord<IsELF64>(getELFFlags(Arch));                     // e_flags
   Str.writeLE16(IsELF64 ? sizeof(Elf64_Ehdr) : sizeof(Elf32_Ehdr)); // e_ehsize
   static_assert(sizeof(Elf64_Ehdr) == 64 && sizeof(Elf32_Ehdr) == 52,
                 "Elf_Ehdr sizes cannot be derived from sizeof");
   Str.writeLE16(0); // e_phentsize
   Str.writeLE16(0); // e_phnum
   Str.writeLE16(IsELF64 ? sizeof(Elf64_Shdr)
@@ skipping 19 matching lines @@
   // between entries.
   assert(WriteAmt % Align == 0);
   const Elf64_Xword ShFlags = SHF_ALLOC | SHF_MERGE;
   std::string SecBuffer;
   llvm::raw_string_ostream SecStrBuf(SecBuffer);
   SecStrBuf << ".rodata.cst" << WriteAmt;
   ELFDataSection *Section = createSection<ELFDataSection>(
       SecStrBuf.str(), SHT_PROGBITS, ShFlags, Align, WriteAmt);
   RODataSections.push_back(Section);
   SizeT OffsetInSection = 0;
-  // The symbol table entry doesn't need to know the defined symbol's
-  // size since this is in a section with a fixed Entry Size.
+  // The symbol table entry doesn't need to know the defined symbol's size
+  // since this is in a section with a fixed Entry Size.
   const SizeT SymbolSize = 0;
   Section->setFileOffset(alignFileOffset(Align));
 
   // If the -reorder-pooled-constant option is set to true, we should shuffle
   // the constants before we emit them.
   if (Ctx.getFlags().shouldReorderPooledConstants() && !Pool.empty()) {
     // Use the constant's kind value as the salt for creating random number
     // generator.
     Operand::OperandKind K = (*Pool.begin())->getKind();
     RandomNumberGenerator RNG(Ctx.getFlags().getRandomSeed(),
@@ skipping 14 matching lines @@
                              OffsetInSection, SymbolSize);
     StrTab->add(SymName);
     typename ConstType::PrimType Value = Const->getValue();
     memcpy(Buf, &Value, WriteAmt);
     Str.writeBytes(llvm::StringRef(Buf, WriteAmt));
     OffsetInSection += WriteAmt;
   }
   Section->setSize(OffsetInSection);
 }
 
-// Instantiate known needed versions of the template, since we are
-// defining the function in the .cpp file instead of the .h file.
-// We may need to instantiate constant pools for integers as well
-// if we do constant-pooling of large integers to remove them
-// from the instruction stream (fewer bytes controlled by an attacker).
+// Instantiate known needed versions of the template, since we are defining the
+// function in the .cpp file instead of the .h file. We may need to instantiate
+// constant pools for integers as well if we do constant-pooling of large
+// integers to remove them from the instruction stream (fewer bytes controlled
+// by an attacker).
 template void ELFObjectWriter::writeConstantPool<ConstantFloat>(Type Ty);
 
 template void ELFObjectWriter::writeConstantPool<ConstantDouble>(Type Ty);
 
 template void ELFObjectWriter::writeConstantPool<ConstantInteger32>(Type Ty);
 
 void ELFObjectWriter::writeAllRelocationSections() {
   writeRelocationSections(RelTextSections);
   writeRelocationSections(RelDataSections);
   writeRelocationSections(RelRODataSections);
@@ skipping 112 matching lines @@
   if (ELF64) {
     writeELFHeaderInternal<true>(ShOffset, ShStrTab->getNumber(),
                                  AllSections.size());
   } else {
     writeELFHeaderInternal<false>(ShOffset, ShStrTab->getNumber(),
                                   AllSections.size());
   }
 }
 
 } // end of namespace Ice