Subzero: Improve class definition hygiene.

src/IceELFSection.h

 //===- subzero/src/IceELFSection.h - Model of ELF sections ------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Representation of ELF sections.
@@ skipping 10 matching lines @@
 
 using namespace llvm::ELF;
 
 namespace Ice {
 
 class ELFStreamer;
 class ELFStringTableSection;
 
 // Base representation of an ELF section.
 class ELFSection {
+  ELFSection() = delete;
   ELFSection(const ELFSection &) = delete;
   ELFSection &operator=(const ELFSection &) = delete;
 
 public:
   // Sentinel value for a section number/index for before the final
   // section index is actually known. The dummy NULL section will be assigned
   // number 0, and it is referenced by the dummy 0-th symbol in the symbol
   // table, so use max() instead of 0.
   enum { NoSectionNumber = std::numeric_limits<SizeT>::max() };
 
@@ skipping 49 matching lines @@
   // be fully initialized before writing.
   Elf64_Shdr Header;
 
   // The number of the section after laying out sections.
   SizeT Number;
 };
 
 // Models text/code sections. Code is written out incrementally and the
 // size of the section is then updated incrementally.
 class ELFTextSection : public ELFSection {
+  ELFTextSection() = delete;
   ELFTextSection(const ELFTextSection &) = delete;
   ELFTextSection &operator=(const ELFTextSection &) = delete;
 
 public:
   using ELFSection::ELFSection;
 
   void appendData(ELFStreamer &Str, const llvm::StringRef MoreData);
 };
 
 // Models data/rodata sections. Data is written out incrementally and the
 // size of the section is then updated incrementally.
 // Some rodata sections may have fixed entsize and duplicates may be mergeable.
 class ELFDataSection : public ELFSection {
+  ELFDataSection() = delete;
   ELFDataSection(const ELFDataSection &) = delete;
   ELFDataSection &operator=(const ELFDataSection &) = delete;
 
 public:
   using ELFSection::ELFSection;
 
   void appendData(ELFStreamer &Str, const llvm::StringRef MoreData);
 
   void appendZeros(ELFStreamer &Str, SizeT NumBytes);
 
@@ skipping 25 matching lines @@
 
   SizeT getNumber() const {
     assert(Number != UnknownNumber);
     return Number;
   }
 };
 
 // Models a symbol table. Symbols may be added up until updateIndices is
 // called. At that point the indices of each symbol will be finalized.
 class ELFSymbolTableSection : public ELFSection {
+  ELFSymbolTableSection() = delete;
+  ELFSymbolTableSection(const ELFSymbolTableSection &) = delete;
+  ELFSymbolTableSection &operator=(const ELFSymbolTableSection &) = delete;
+
 public:
   using ELFSection::ELFSection;
 
   // Create initial entry for a symbol when it is defined.
   // Each entry should only be defined once.
   // We might want to allow Name to be a dummy name initially, then
   // get updated to the real thing, since Data initializers are read
   // before the bitcode's symbol table is read.
   void createDefinedSym(const IceString &Name, uint8_t Type, uint8_t Binding,
                         ELFSection *Section, RelocOffsetT Offset, SizeT Size);
@@ skipping 24 matching lines @@
   void writeSymbolMap(ELFStreamer &Str, const SymMap &Map);
 
   // Keep Local and Global symbols separate, since the sh_info needs to
   // know the index of the last LOCAL.
   SymMap LocalSymbols;
   SymMap GlobalSymbols;
 };
 
 // Models a relocation section.
 class ELFRelocationSection : public ELFSection {
+  ELFRelocationSection() = delete;
   ELFRelocationSection(const ELFRelocationSection &) = delete;
   ELFRelocationSection &operator=(const ELFRelocationSection &) = delete;
 
 public:
   using ELFSection::ELFSection;
 
   const ELFSection *getRelatedSection() const { return RelatedSection; }
   void setRelatedSection(const ELFSection *Section) {
     RelatedSection = Section;
   }
@@ skipping 18 matching lines @@
   FixupList Fixups;
 };
 
 // Models a string table.  The user will build the string table by
 // adding strings incrementally.  At some point, all strings should be
 // known and doLayout() should be called. After that, no other
 // strings may be added.  However, the final offsets of the strings
 // can be discovered and used to fill out section headers and symbol
 // table entries.
 class ELFStringTableSection : public ELFSection {
+  ELFStringTableSection() = delete;
   ELFStringTableSection(const ELFStringTableSection &) = delete;
   ELFStringTableSection &operator=(const ELFStringTableSection &) = delete;
 
 public:
   using ELFSection::ELFSection;
 
   // Add a string to the table, in preparation for final layout.
   void add(const IceString &Str);
 
   // Finalizes the layout of the string table and fills in the section Data.
@@ skipping 99 matching lines @@
       Rel.setSymbolAndType(Symbol->getNumber(), Fixup.kind());
       Str.writeAddrOrOffset<IsELF64>(Rel.r_offset);
       Str.writeELFWord<IsELF64>(Rel.r_info);
     }
   }
 }
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEELFSECTION_H