[ELF] Make InputSection smaller

[MaskRay]

Summary

On LP64/Windows platforms, this decreases sizeof(InputSection) from 208 (larger
on Windows) to 184.

For a large executable (7.6GiB, inputSections.size()=5105122,
make<InputSection> called 4835760 times), this decreases cgroup
memory.max_usage_in_bytes by 0.6%

[MaskRay]

Improve a basic block sections comment

[grimar]

LGTM

[MaskRay]

Fix Windows

[lxfind]

lld/ELF/InputSection.h

393

Curious, what's the purpose of static_assert like this? Will the program behave incorrectly if the size of InputSection is larger than 184?
Asking because with this assertion whoever adding or removing fields from this class or the base class will need to remember updating this static_assert accordingly, which I am not sure is scalable. That doesn't seem to serve the typical purpose of static_assert (which should be that the program behavior depends on it to be true) I think?

[MaskRay]

lld/ELF/InputSection.h

393

There are a few other static_assert for objects which are allocated a lot. This is important to prevent accidental regression or memory usage and performance.

[lxfind]

lld/ELF/InputSection.h

393

There is a static_assert for SectionPiece, which makes sense since it's small and simple, and it makes sense that we want to make sure the bit trick makes it fall within 16 bytes.
But I don't think a class as complicated as InputSection falls into that category. InputSection has 3 levels of inheritance hierarchy, with a ton of members. 184 is kind of like a magic number already (you probably have the compiler printed out the size instead of eye-balled it). This doesn't seem to be the right way to catch memory increases of classes.
If we really want to have some guarantee here, it might make sense to add a static_assert for SectionBase since it's extended by everything else, but imho not a class so far down the inheritance structure.
Finally, I'm not sure it would serve a real purpose. Whenever anyone is touching these classes, they would just go ahead and modify the static_assert to make it pass since it''s so complicated anyway, which is pure trouble than catching anything because there isn't really a way to "accidentally" regress it. A regression would come from adding fields on purpose.
Maybe I am missing something here. I see that @espindola added the other assert, what do you think?

[MaskRay]

lld/ELF/InputSection.h

393

More than 90% sections are InputSection and not other SectionBase derivatives. We even have bits in SectionBase which are only used by InputSection. The type we want to optimize for is InputSection, not SectionBase (which is not allocated independently), and InputSection is an apparent memory usage/performance bottleneck so I think static_assert is on topic.

If we really want to have some guarantee here, it might make sense to add a static_assert for SectionBase since it's extended by everything else, but imho not a class so far down the inheritance structure.

This static_assert is very useful and I felt bad that we had not added it earlier so that D68065 regressed the memory usage by more than 1%.

This is of course not pure trouble - the fields are very stable. You can search for other logs about my optimization on the structure members.

lld/ELF/InputSection.h

public:
 
   // This pointer points to the "real" instance of this instance.
   // Usually Repl == this. However, if ICF merges two sections,
   // Repl pointer of one section points to another section. So,
   // if you need to get a pointer to this instance, do not use
   // this but instead this->Repl.
   SectionBase *repl;
 
-  unsigned sectionKind : 3;
+  uint8_t sectionKind : 3;
 
   // The next two bit fields are only used by InputSectionBase, but we
   // put them here so the struct packs better.
 
-  unsigned bss : 1;
+  uint8_t bss : 1;
 
   // Set for sections that should not be folded by ICF.
-  unsigned keepUnique : 1;
+  uint8_t keepUnique : 1;
 
   // The 1-indexed partition that this section is assigned to by the garbage
   // collector, or 0 if this section is dead. Normally there is only one
   // partition, so this will either be 0 or 1.
   uint8_t partition;
   elf::Partition &getPartition() const;
 
   // These corresponds to the fields in Elf_Shdr.
public:
   }
 
   // If basic block sections are enabled, many code sections could end up with
   // one or two jump instructions at the end that could be relaxed to a smaller
   // instruction. The members below help trimming the trailing jump instruction
   // and shrinking a section.
   unsigned bytesDropped = 0;
 
+  // Whether the section needs to be padded with a NOP filler due to
+  // deleteFallThruJmpInsn.
+  bool nopFiller = false;
+
   void drop_back(uint64_t num) { bytesDropped += num; }
 
   void push_back(uint64_t num) {
     assert(bytesDropped >= num);
     bytesDropped -= num;
   }
 
   void trim() {
public:
   void relocateAlloc(uint8_t *buf, uint8_t *bufEnd);
   static uint64_t getRelocTargetVA(const InputFile *File, RelType Type,
                                    int64_t A, uint64_t P, const Symbol &Sym,
                                    RelExpr Expr);
 
   // The native ELF reloc data type is not very convenient to handle.
   // So we convert ELF reloc records to our own records in Relocations.cpp.
   // This vector contains such "cooked" relocations.
-  std::vector<Relocation> relocations;
-
-  // Indicates that this section needs to be padded with a NOP filler if set to
-  // true.
-  bool nopFiller = false;
+  SmallVector<Relocation, 0> relocations;
 
   // These are modifiers to jump instructions that are necessary when basic
   // block sections are enabled.  Basic block sections creates opportunities to
   // relax jump instructions at basic block boundaries after reordering the
   // basic blocks.
-  std::vector<JumpInstrMod> jumpInstrMods;
+  SmallVector<JumpInstrMod, 0> jumpInstrMods;
 
   // A function compiled with -fsplit-stack calling a function
   // compiled without -fsplit-stack needs its prologue adjusted. Find
   // such functions and adjust their prologues.  This is very similar
   // to relocation. See https://gcc.gnu.org/wiki/SplitStacks for more
   // information.
   template <typename ELFT>
   void adjustSplitStackFunctionPrologues(uint8_t *buf, uint8_t *end);

 
 private:
   template <class ELFT, class RelTy>
   void copyRelocations(uint8_t *buf, llvm::ArrayRef<RelTy> rels);
 
   template <class ELFT> void copyShtGroup(uint8_t *buf);
 };
 
+static_assert(sizeof(InputSection) <= 184, "InputSection is too big");
+
 inline bool isDebugSection(const InputSectionBase &sec) {
   return sec.name.startswith(".debug") || sec.name.startswith(".zdebug");
 }
 
 // The list of all input sections.
 extern std::vector<InputSectionBase *> inputSections;
 
 // The set of TOC entries (.toc + addend) for which we should not apply