[ELF] - Remove OutputSectionFactory::lookup method

[grimar]

Summary

What about removing OutputSectionFactory::lookup method ?
It is single line and IMO removing will decrease amount
of code without visible hurt.

[• rafael]

How about just defining it inline?

One of the annoyances of the Map interface is the just using [] adds
an entry. Having the Map be private means we only have to look at a
few places to know that we don't accidentally create entries when we
don't want to: the two visible methods are named create and lookup.

Cheers,
Rafael

[grimar]

In D19111#401074, @rafael wrote:

How about just defining it inline?

One of the annoyances of the Map interface is the just using [] adds
an entry. Having the Map be private means we only have to look at a
few places to know that we don't accidentally create entries when we
don't want to: the two visible methods are named create and lookup.

Cheers,
Rafael

Ok. Motivation to keep it private under guard of method call was clear,
I just assumed we will not use [] to have that effect :)

[grimar]

Made it inline in r266304.

[ruiu]

By "inline", I think it means moving the definition of the function into the class definition, instead of inlining function definition to the places where the function is used.

[grimar]

In D19111#401398, @ruiu wrote:

By "inline", I think it means moving the definition of the function into the class definition, instead of inlining function definition to the places where the function is used.

That what was done in r266304. Current patch abandoned.

ELF/Writer.cpp

 template <class ELFT> class OutputSectionFactory {
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::uint uintX_t;
 
 public:
   std::pair<OutputSectionBase<ELFT> *, bool> create(InputSectionBase<ELFT> *C,
                                                     StringRef OutsecName);
 
-  OutputSectionBase<ELFT> *lookup(StringRef Name, uint32_t Type, uintX_t Flags);
+  SmallDenseMap<SectionKey<ELFT::Is64Bits>, OutputSectionBase<ELFT> *> Map;
 
 private:
   SectionKey<ELFT::Is64Bits> createKey(InputSectionBase<ELFT> *C,
                                        StringRef OutsecName);
-
-  SmallDenseMap<SectionKey<ELFT::Is64Bits>, OutputSectionBase<ELFT> *> Map;
 };
 }
 
 template <class ELFT>
 std::pair<OutputSectionBase<ELFT> *, bool>
 OutputSectionFactory<ELFT>::create(InputSectionBase<ELFT> *C,
                                    StringRef OutsecName) {
   SectionKey<ELFT::Is64Bits> Key = createKey(C, OutsecName);
OutputSectionFactory<ELFT>::create(InputSectionBase<ELFT> *C,
   case InputSectionBase<ELFT>::MipsReginfo:
     Sec = new MipsReginfoOutputSection<ELFT>();
     break;
   }
   return {Sec, true};
 }
 
 template <class ELFT>
-OutputSectionBase<ELFT> *OutputSectionFactory<ELFT>::lookup(StringRef Name,
-                                                            uint32_t Type,
-                                                            uintX_t Flags) {
-  return Map.lookup({Name, Type, Flags, 0});
-}
-
-template <class ELFT>
 SectionKey<ELFT::Is64Bits>
 OutputSectionFactory<ELFT>::createKey(InputSectionBase<ELFT> *C,
                                       StringRef OutsecName) {
   const Elf_Shdr *H = C->getSectionHdr();
   uintX_t Flags = H->sh_flags & ~SHF_GROUP;
 
   // For SHF_MERGE we create different output sections for each alignment.
   // This makes each output section simple and keeps a single level mapping from
for (InputSectionBase<ELFT> *C : F->getSections()) {
         OutputSections.push_back(Sec);
         RegularSections.push_back(Sec);
       }
       Sec->addSection(C);
     }
   }
 
   Out<ELFT>::Bss = static_cast<OutputSection<ELFT> *>(
-      Factory.lookup(".bss", SHT_NOBITS, SHF_ALLOC | SHF_WRITE));
+      Factory.Map.lookup({".bss", SHT_NOBITS, SHF_ALLOC | SHF_WRITE}));
 
   // If we have a .opd section (used under PPC64 for function descriptors),
   // store a pointer to it here so that we can use it later when processing
   // relocations.
-  Out<ELFT>::Opd = Factory.lookup(".opd", SHT_PROGBITS, SHF_WRITE | SHF_ALLOC);
+  Out<ELFT>::Opd =
+      Factory.Map.lookup({".opd", SHT_PROGBITS, SHF_WRITE | SHF_ALLOC});
 
-  Out<ELFT>::Dynamic->PreInitArraySec = Factory.lookup(
-      ".preinit_array", SHT_PREINIT_ARRAY, SHF_WRITE | SHF_ALLOC);
+  Out<ELFT>::Dynamic->PreInitArraySec = Factory.Map.lookup({
+    ".preinit_array", SHT_PREINIT_ARRAY, SHF_WRITE | SHF_ALLOC});
   Out<ELFT>::Dynamic->InitArraySec =
-      Factory.lookup(".init_array", SHT_INIT_ARRAY, SHF_WRITE | SHF_ALLOC);
+    Factory.Map.lookup({ ".init_array", SHT_INIT_ARRAY, SHF_WRITE | SHF_ALLOC });
   Out<ELFT>::Dynamic->FiniArraySec =
-      Factory.lookup(".fini_array", SHT_FINI_ARRAY, SHF_WRITE | SHF_ALLOC);
+    Factory.Map.lookup({ ".fini_array", SHT_FINI_ARRAY, SHF_WRITE | SHF_ALLOC });
 
   // Sort section contents for __attribute__((init_priority(N)).
   sortInitFini(Out<ELFT>::Dynamic->InitArraySec);
   sortInitFini(Out<ELFT>::Dynamic->FiniArraySec);
-  sortCtorsDtors(Factory.lookup(".ctors", SHT_PROGBITS, SHF_WRITE | SHF_ALLOC));
-  sortCtorsDtors(Factory.lookup(".dtors", SHT_PROGBITS, SHF_WRITE | SHF_ALLOC));
+  sortCtorsDtors(Factory.Map.lookup({".ctors", SHT_PROGBITS, SHF_WRITE | SHF_ALLOC}));
+  sortCtorsDtors(Factory.Map.lookup({".dtors", SHT_PROGBITS, SHF_WRITE | SHF_ALLOC}));
 
   // The linker needs to define SECNAME_start, SECNAME_end and SECNAME_stop
   // symbols for sections, so that the runtime can get the start and end
   // addresses of each section by section name. Add such symbols.
   if (!Config->Relocatable) {
     addStartEndSymbols();
     for (OutputSectionBase<ELFT> *Sec : RegularSections)
       addStartStopSymbols(Sec);