reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

  876     mc = make<MergeChunk>(c->getAlignment());

  577         lookups.push_back(make<OrdinalOnlyChunk>(ord));
  578         addresses.push_back(make<OrdinalOnlyChunk>(ord));
  581       auto *c = make<HintNameChunk>(s->getExternalName(), ord);
  582       lookups.push_back(make<LookupChunk>(c));
  583       addresses.push_back(make<LookupChunk>(c));
  587     lookups.push_back(make<NullChunk>(config->wordsize));
  588     addresses.push_back(make<NullChunk>(config->wordsize));
  594     dllNames.push_back(make<StringChunk>(syms[0]->getDLLName()));
  595     auto *dir = make<ImportDirectoryChunk>(dllNames.back());
  601   dirs.push_back(make<NullChunk>(sizeof(ImportDirectoryTableEntry)));
  631     dllNames.push_back(make<StringChunk>(syms[0]->getDLLName()));
  632     auto *dir = make<DelayDirectoryChunk>(dllNames.back());
  638       auto *a = make<DelayAddressChunk>(t);
  643         names.push_back(make<OrdinalOnlyChunk>(s->getOrdinal()));
  645         auto *c = make<HintNameChunk>(extName, 0);
  646         names.push_back(make<LookupChunk>(c));
  652     addresses.push_back(make<NullChunk>(8));
  653     names.push_back(make<NullChunk>(8));
  657     auto *mh = make<NullChunk>(8);
  668   dirs.push_back(make<NullChunk>(sizeof(delay_import_directory_table_entry)));
  674     return make<TailMergeChunkX64>(dir, helper);
  676     return make<TailMergeChunkX86>(dir, helper);
  678     return make<TailMergeChunkARM>(dir, helper);
  680     return make<TailMergeChunkARM64>(dir, helper);
  690     return make<ThunkChunkX64>(s, tailMerge);
  692     return make<ThunkChunkX86>(s, tailMerge);
  694     return make<ThunkChunkARM>(s, tailMerge);
  696     return make<ThunkChunkARM64>(s, tailMerge);
  707   auto *dllName = make<StringChunk>(sys::path::filename(config->outputFile));
  708   auto *addressTab = make<AddressTableChunk>(maxOrdinal);
  712       names.push_back(make<StringChunk>(e.exportName));
  718     e.forwardChunk = make<StringChunk>(e.forwardTo);
  722   auto *nameTab = make<NamePointersChunk>(names);
  723   auto *ordinalTab = make<ExportOrdinalChunk>(names.size());
  724   auto *dir = make<ExportDirectoryChunk>(maxOrdinal, names.size(), dllName,

   73   config = make<Configuration>();
   74   symtab = make<SymbolTable>();
   75   driver = make<LinkerDriver>();
  162   make<std::unique_ptr<MemoryBuffer>>(std::move(mb)); // take ownership
  187       make<std::unique_ptr<Archive>>(std::move(file)); // take ownership
  194     symtab->addFile(make<ArchiveFile>(mbref));
  198       symtab->addFile(make<LazyObjFile>(mbref));
  200       symtab->addFile(make<BitcodeFile>(mbref, "", 0));
  205       symtab->addFile(make<LazyObjFile>(mbref));
  207       symtab->addFile(make<ObjFile>(mbref));
  257     InputFile *imp = make<ImportFile>(mb);
  265     obj = make<ObjFile>(mb);
  267     obj = make<BitcodeFile>(mb, parentName, offsetInArchive);
 1028   ObjFile *f = make<ObjFile>(convertResToCOFF(resources, resourceObjFiles));

  746   make<std::unique_ptr<MemoryBuffer>>(std::move(*e)); // take ownership

  147     file = make<BitcodeFile>(mb, "", 0, std::move(symbols));
  149     file = make<ObjFile>(mb, std::move(symbols));
  270   auto *c = make<SectionChunk>(this, sec);
  397     return make<DefinedRegular>(this, /*Name*/ "", /*IsCOMDAT*/ false,
  586     auto *c = make<CommonChunk>(sym);
  603     return make<DefinedAbsolute>(name, sym);
  637       leader = make<DefinedRegular>(this, /*Name*/ "", /*IsCOMDAT*/ false,
  798     dwarf = make<DWARFCache>(DWARFContext::create(*getCOFFObj()));
  815     dwarf = make<DWARFCache>(DWARFContext::create(*getCOFFObj()));

  461     sym = reinterpret_cast<Symbol *>(make<SymbolUnion>());
  798     auto *obj = make<ObjFile>(MemoryBufferRef(object, "lto.tmp"));

  115     return make<ImportThunkChunkX64>(s);
  117     return make<ImportThunkChunkX86>(s);
  119     return make<ImportThunkChunkARM64>(s);
  121   return make<ImportThunkChunkARM>(s);

  363       : Defined(DefinedLocalImportKind, n), data(make<LocalImportChunk>(s)) {}

  376     c = make<RangeExtensionThunkARM>(target);
  379     c = make<RangeExtensionThunkARM64>(target);
  384   Defined *d = make<DefinedSynthetic>("", c);
  803       sec = make<OutputSection>(name, outChars);
  924     debugDirectory = make<DebugDirectoryChunk>(debugRecords, config->repro);
  933     buildId = make<CVDebugRecordChunk>();
 1669   RVATableChunk *tableChunk = make<RVATableChunk>(std::move(tableSymbols));
 1694   PseudoRelocTableChunk *table = make<PseudoRelocTableChunk>(rels);
 1696   EmptyChunk *endOfList = make<EmptyChunk>();
 1711   AbsolutePointerChunk *ctorListHead = make<AbsolutePointerChunk>(-1);
 1712   AbsolutePointerChunk *ctorListEnd = make<AbsolutePointerChunk>(0);
 1713   AbsolutePointerChunk *dtorListHead = make<AbsolutePointerChunk>(-1);
 1714   AbsolutePointerChunk *dtorListEnd = make<AbsolutePointerChunk>(0);
 1919     relocSec->addChunk(make<BaserelChunk>(page, &v[i], &v[0] + j));
 1925   relocSec->addChunk(make<BaserelChunk>(page, &v[i], &v[0] + j));
 1933   pSec = make<PartialSection>(name, outChars);

  558   auto *ps = make<Patch843419Section>(isec, patcheeOffset);

  436     psec = make<Patch657417Section>(isec, sr.off, sr.instr, destIsARM);
  454     psec = make<Patch657417Section>(isec, sr.off, sr.instr, isBLX(sr.instr));

   94   config = make<Configuration>();
   95   driver = make<LinkerDriver>();
   96   script = make<LinkerScript>();
   97   symtab = make<SymbolTable>();
  183     make<std::unique_ptr<MemoryBuffer>>(std::move(mb));
  198     files.push_back(make<BinaryFile>(mbref));
  233         files.push_back(make<LazyObjFile>(p.first, path, p.second));
  238     files.push_back(make<ArchiveFile>(std::move(file)));
  258         make<SharedFile>(mbref, withLOption ? path::filename(path) : path));
  263       files.push_back(make<LazyObjFile>(mbref, "", 0));
 1421     auto *bss = make<BssSection>("COMMON", s->size, s->alignment);
 1808   Out::elfHeader = make<OutputSection>("", 0, SHF_ALLOC);

  119   make<std::unique_ptr<MemoryBuffer>>(std::move(mb)); // take MB ownership
  267   dwarf = make<DWARFCache>(std::make_unique<DWARFContext>(
  785   return make<InputSection>(sec->file, sec->flags, sec->type, sec->alignment,
  807       in.armAttributes = make<InputSection>(*this, sec, name);
  855       InputSection *relocSec = make<InputSection>(*this, sec, name);
  887       InputSection *relocSec = make<InputSection>(*this, sec, name);
  968     return make<EhInputSection>(*this, sec, name);
  971     return make<MergeInputSection>(*this, sec, name);
  972   return make<InputSection>(*this, sec, name);
 1021         this->symbols[i] = make<Undefined>(this, name, binding, stOther, type);
 1023         this->symbols[i] = make<Undefined>(this, name, binding, stOther, type,
 1027             make<Defined>(this, name, binding, stOther, type, value, size, sec);
 1445   auto *section = make<InputSection>(this, SHF_ALLOC | SHF_WRITE, SHT_PROGBITS,
 1469     return make<BitcodeFile>(mb, archiveName, offsetInArchive);
 1473     return make<ObjFile<ELF32LE>>(mb, archiveName);
 1475     return make<ObjFile<ELF32BE>>(mb, archiveName);
 1477     return make<ObjFile<ELF64LE>>(mb, archiveName);
 1479     return make<ObjFile<ELF64BE>>(mb, archiveName);

   87     sec = make<OutputSection>(name, SHT_PROGBITS, 0);
   98     cmdRef = make<OutputSection>(name, SHT_PROGBITS, 0);
  531   aether = make<OutputSection>("", 0, SHF_ALLOC);
 1122     PhdrEntry *phdr = make<PhdrEntry>(cmd.type, cmd.flags ? *cmd.flags : PF_R);

   99     sectionCommands.push_back(make<InputSectionDescription>(""));

  568       make<BssSection>(isRO ? ".bss.rel.ro" : ".bss", symSize, ss.alignment);
  575     osec->sectionCommands.push_back(make<InputSectionDescription>(""));
 1342       auto *directSym = make<Defined>(cast<Defined>(sym));
 1689   auto *ts = make<ThunkSection>(os, off);

  274   SymbolAssignment *cmd = make<SymbolAssignment>(name, e, getCurrentLocation());
  517   v.push_back(make<SymbolAssignment>(".", moveDot, getCurrentLocation()));
  661   auto *cmd = make<InputSectionDescription>(filePattern);
  844       auto *isd = make<InputSectionDescription>(tok);
  908     return make<SymbolAssignment>(".", readAssert(), getCurrentLocation());
  938   return make<SymbolAssignment>(name, e, getCurrentLocation());
 1102   return make<ByteCommand>(e, size, commandString);
 1479     MemoryRegion *mr = make<MemoryRegion>(tok, origin, length, flags, negFlags);

   70   Symbol *sym = reinterpret_cast<Symbol *>(make<SymbolUnion>());

   85   return make<MergeInputSection>(SHF_MERGE | SHF_STRINGS, SHT_PROGBITS, 1,
  144     return make<MipsAbiFlagsSection<ELFT>>(flags);
  206   return make<MipsOptionsSection<ELFT>>(reginfo);
  251   return make<MipsReginfoSection<ELFT>>(reginfo);
  259   return make<InputSection>(nullptr, SHF_ALLOC, SHT_PROGBITS, 1, contents,
  265   auto *s = make<Defined>(section.file, name, STB_LOCAL, STV_DEFAULT, type,
  364     rec = make<CieRecord>();
 2729   auto *ret = make<GdbIndexSection>();
 3130     return make<MergeTailSection>(name, type, flags, alignment);
 3131   return make<MergeNoTailSection>(name, type, flags, alignment);

  806     return make<AArch64ADRPThunk>(s);
  807   return make<AArch64ABSLongThunk>(s);
  823       return make<ARMV5PILongThunk>(s);
  824     return make<ARMV5ABSLongThunk>(s);
  841       return make<ThumbV6MPILongThunk>(s);
  842     return make<ThumbV6MABSLongThunk>(s);
  878       return make<ARMV7PILongThunk>(s);
  879     return make<ARMV7ABSLongThunk>(s);
  884       return make<ThumbV7PILongThunk>(s);
  885     return make<ThumbV7ABSLongThunk>(s);
  892     return make<MicroMipsR6Thunk>(s);
  894     return make<MicroMipsThunk>(s);
  895   return make<MipsThunk>(s);
  901   return make<PPC32PltCallStub>(isec, rel, s);
  907     return make<PPC64PltCallStub>(s);
  910     return make<PPC64PILongBranchThunk>(s);
  912   return make<PPC64PDLongBranchThunk>(s);

  163         copy = make<InputSection>(cast<InputSection>(*s));
  165         copy = make<EhInputSection>(*es);
  329   in.shStrTab = make<StringTableSection>(".shstrtab", false);
  331   Out::programHeaders = make<OutputSection>("", 0, SHF_ALLOC);
  335     in.strTab = make<StringTableSection>(".strtab", false);
  336     in.symTab = make<SymbolTableSection<ELFT>>(*in.strTab);
  337     in.symTabShndx = make<SymtabShndxSection>();
  340   in.bss = make<BssSection>(".bss", 0, 1);
  349       make<BssSection>(hasDataRelRo ? ".data.rel.ro.bss" : ".bss.rel.ro", 0, 1);
  355       in.mipsRldMap = make<MipsRldMapSection>();
  375       part.elfHeader = make<PartitionElfHeaderSection<ELFT>>();
  379       part.programHeaders = make<PartitionProgramHeadersSection<ELFT>>();
  384       part.buildId = make<BuildIdSection>();
  388     part.dynStrTab = make<StringTableSection>(".dynstr", true);
  389     part.dynSymTab = make<SymbolTableSection<ELFT>>(*part.dynStrTab);
  390     part.dynamic = make<DynamicSection<ELFT>>();
  392       part.relaDyn = make<AndroidPackedRelocationSection<ELFT>>(relaDynName);
  395           make<RelocationSection<ELFT>>(relaDynName, config->zCombreloc);
  398       part.dynSymTab = make<SymbolTableSection<ELFT>>(*part.dynStrTab);
  401       part.verSym = make<VersionTableSection>();
  405         part.verDef = make<VersionDefinitionSection>();
  409       part.verNeed = make<VersionNeedSection<ELFT>>();
  413         part.gnuHashTab = make<GnuHashTableSection>();
  418         part.hashTab = make<HashTableSection>();
  428       part.relrDyn = make<RelrSection<ELFT>>();
  434         part.ehFrameHdr = make<EhFrameHeader>();
  437       part.ehFrame = make<EhFrameSection>();
  444       part.armExidx = make<ARMExidxSyntheticSection>();
  453     in.partEnd = make<BssSection>(".part.end", config->maxPageSize, 1);
  457     in.partIndex = make<PartitionIndexSection>();
  467     in.mipsGot = make<MipsGotSection>();
  470     in.got = make<GotSection>();
  475     in.ppc32Got2 = make<PPC32Got2Section>();
  480     in.ppc64LongBranchTarget = make<PPC64LongBranchTargetSection>();
  484   in.gotPlt = make<GotPltSection>();
  486   in.igotPlt = make<IgotPltSection>();
  503   in.relaPlt = make<RelocationSection<ELFT>>(
  513   in.relaIplt = make<RelocationSection<ELFT>>(
  518   in.plt = make<PltSection>(false);
  520   in.iplt = make<PltSection>(true);
  524     add(make<GnuPropertySection>());
  532     add(make<GnuStackSection>());
  729         make<Defined>(isec->file, "", STB_LOCAL, /*stOther=*/0, STT_SECTION,
 2052     ret.push_back(make<PhdrEntry>(type, flags));
 2091   PhdrEntry *relRo = make<PhdrEntry>(PT_GNU_RELRO, PF_R);
 2150   PhdrEntry *tlsHdr = make<PhdrEntry>(PT_TLS, PF_R);
 2218   PhdrEntry *entry = make<PhdrEntry>(pType, pFlags);

   89   config = make<Configuration>();
   90   symtab = make<SymbolTable>();
  213     make<std::unique_ptr<MemoryBuffer>>(std::move(mb));
  246     files.push_back(make<ArchiveFile>(mbref));
  457                                     make<InputGlobal>(wasmGlobal, nullptr));
  472       make<SyntheticFunction>(nullSignature, "__wasm_call_ctors"));
  479         make<SyntheticFunction>(nullSignature, "__wasm_apply_relocs"));
  508         make<SyntheticFunction>(nullSignature, "__wasm_init_memory"));
  517         make<SyntheticFunction>(i32ArgSignature, "__wasm_init_tls"));

   55   make<std::unique_ptr<MemoryBuffer>>(std::move(mb)); // take MB ownership
   70       return make<SharedFile>(mb);
   71     return make<ObjFile>(mb, archiveName);
   75     return make<BitcodeFile>(mb, archiveName);
  297       customSections.emplace_back(make<InputSection>(section, this));
  320     auto* seg = make<InputSegment>(s, this);
  333     auto* func = make<InputFunction>(types[funcTypes[i]], &funcs[i], this);
  341     globals.emplace_back(make<InputGlobal>(g, this));
  345     events.emplace_back(make<InputEvent>(types[e.Type.SigIndex], e, this));
  400       return make<DefinedFunction>(name, flags, this, func);
  410       return make<DefinedData>(name, flags, this, seg, offset, size);
  419       return make<DefinedGlobal>(name, flags, this, global);
  425     return make<SectionSymbol>(flags, section, this);
  431       return make<DefinedEvent>(name, flags, this, event);
  445       return make<UndefinedFunction>(name, sym.Info.ImportName,
  453       return make<UndefinedData>(name, flags, this);
  457       return make<UndefinedGlobal>(name, sym.Info.ImportName,

   77     auto *obj = make<ObjFile>(MemoryBufferRef(filename, "lto.tmp"), "");
  109   Symbol *sym = reinterpret_cast<Symbol *>(make<SymbolUnion>());
  585     variant = reinterpret_cast<Symbol *>(make<SymbolUnion>());
  627   auto *func = make<SyntheticFunction>(sig, sym->getName(), debugName);

  131     OutputSection *sec = make<CustomSection>(name, pair.second);
  133       auto *sym = make<OutputSectionSymbol>(sec);
  167     addSection(make<RelocSection>(name, sec));
  348   addSection(make<CodeSection>(out.functionSec->inputFunctions));
  349   addSection(make<DataSection>(segments));
  669         s = make<OutputSegment>(name);
  960   out.dylinkSec = make<DylinkSection>();
  961   out.typeSec = make<TypeSection>();
  962   out.importSec = make<ImportSection>();
  963   out.functionSec = make<FunctionSection>();
  964   out.tableSec = make<TableSection>();
  965   out.memorySec = make<MemorySection>();
  966   out.globalSec = make<GlobalSection>();
  967   out.eventSec = make<EventSection>();
  968   out.exportSec = make<ExportSection>();
  969   out.startSec = make<StartSection>(segments.size());
  970   out.elemSec = make<ElemSection>();
  971   out.dataCountSec = make<DataCountSection>(segments);
  972   out.linkingSec = make<LinkingSection>(initFunctions, segments);
  973   out.nameSec = make<NameSection>();
  974   out.producersSec = make<ProducersSection>();
  975   out.targetFeaturesSec = make<TargetFeaturesSection>();