Lines Matching +full:dll +full:- +full:config
1 //===- Chunks.cpp ---------------------------------------------------------===//
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
38 setRelocs(file->getCOFFObj()->getRelocations(header));
43 if (Expected<StringRef> e = file->getCOFFObj()->getSectionName(header))
49 setAlignment(header->getAlignment());
51 hasData = !(header->Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA);
54 // enabled, treat non-comdat sections as roots. Generally optimized object
55 // files will be built with -ffunction-sections or /Gy, so most things worth
58 live = !file->ctx.config.doGC || !isCOMDAT();
76 // sections have section-relative relocations against absolute symbols.
80 if (sec->isCodeView())
90 uint64_t secRel = s - os->getRVA();
92 error("overflow in SECREL relocation in section: " + sec->getSectionName());
108 add16(off, os->sectionIndex);
124 case IMAGE_REL_AMD64_REL32: add32(off, s - p - 4); break;
125 case IMAGE_REL_AMD64_REL32_1: add32(off, s - p - 5); break;
126 case IMAGE_REL_AMD64_REL32_2: add32(off, s - p - 6); break;
127 case IMAGE_REL_AMD64_REL32_3: add32(off, s - p - 7); break;
128 case IMAGE_REL_AMD64_REL32_4: add32(off, s - p - 8); break;
129 case IMAGE_REL_AMD64_REL32_5: add32(off, s - p - 9); break;
131 applySecIdx(off, os, file->ctx.outputSections.size());
149 case IMAGE_REL_I386_REL32: add32(off, s - p - 4); break;
151 applySecIdx(off, os, file->ctx.outputSections.size());
213 if (os && (os->header.Characteristics & IMAGE_SCN_MEM_EXECUTE))
223 case IMAGE_REL_ARM_BRANCH20T: applyBranch20T(off, sx - p - 4); break;
224 case IMAGE_REL_ARM_BRANCH24T: applyBranch24T(off, sx - p - 4); break;
225 case IMAGE_REL_ARM_BLX23T: applyBranch24T(off, sx - p - 4); break;
227 applySecIdx(off, os, file->ctx.outputSections.size());
230 case IMAGE_REL_ARM_REL32: add32(off, sx - p - 4); break;
245 imm = (s >> shift) - (p >> shift);
277 if ((imm & ((1 << size) - 1)) != 0)
285 applyArm64Imm(off, (s - os->getRVA()) & 0xfff, 0);
292 uint64_t secRel = (s - os->getRVA()) >> 12;
295 sec->getSectionName());
304 applyArm64Ldr(off, (s - os->getRVA()) & 0xfff);
333 case IMAGE_REL_ARM64_BRANCH26: applyArm64Branch26(off, s - p); break;
334 case IMAGE_REL_ARM64_BRANCH19: applyArm64Branch19(off, s - p); break;
335 case IMAGE_REL_ARM64_BRANCH14: applyArm64Branch14(off, s - p); break;
348 applySecIdx(off, os, file->ctx.outputSections.size());
350 case IMAGE_REL_ARM64_REL32: add32(off, s - p - 4); break;
365 if (fromChunk->isCodeView() || fromChunk->isDWARF() || isMinGW)
370 ObjFile *file = fromChunk->file;
373 name = sym->getName();
376 check(file->getCOFFObj()->getSymbol(rel.SymbolTableIndex));
377 name = check(file->getCOFFObj()->getSymbolName(coffSym));
418 write32le(buf - sizeof(uint32_t), entryThunk->getRVA() - rva + 1);
423 auto *sym = dyn_cast_or_null<Defined>(file->getSymbol(rel.SymbolTableIndex));
428 Chunk *c = sym ? sym->getChunk() : nullptr;
429 OutputSection *os = c ? file->ctx.getOutputSection(c) : nullptr;
437 maybeReportRelocationToDiscarded(this, sym, rel, file->ctx.config.mingw);
441 uint64_t s = sym->getRVA();
445 uint64_t imageBase = file->ctx.config.imageBase;
471 warn("some relocations in " + file->getName() + " are not sorted");
500 applyRelocation(&buf[rel.VirtualAddress - vaBegin], rel);
507 assert(child->assocChildren == nullptr &&
511 for (; next != nullptr; prev = next, next = next->assocChildren) {
512 if (next->getSectionName() <= child->getSectionName())
517 assert(prev->assocChildren == next);
518 prev->assocChildren = child;
519 child->assocChildren = next;
550 // Windows-specific.
552 // fixed by the loader if load-time relocation is needed.
559 Symbol *target = file->getSymbol(rel.SymbolTableIndex);
562 res->emplace_back(rva + rel.VirtualAddress, ty);
570 // another DLL) This returns the size the relocation is supposed to update,
588 // *(base + .target) += *(base + .sym) - (base + .sym)
649 // imported from another DLL).
654 dyn_cast_or_null<Defined>(file->getSymbol(rel.SymbolTableIndex));
655 if (!target || !target->isRuntimePseudoReloc)
662 if (!target->getChunk())
665 getRuntimePseudoRelocSize(rel.Type, file->ctx.config.machine);
667 error("unable to automatically import from " + target->getName() +
669 file->getCOFFObj()->getRelocationTypeName(rel.Type) + " in " +
673 int addressSizeInBits = file->ctx.config.is64() ? 64 : 32;
676 "symbol " + target->getName() + " is too narrow (only " +
687 return header->Characteristics & IMAGE_SCN_LNK_COMDAT;
691 // Removed by dead-stripping. If it's removed by ICF, ICF already
694 log("Discarded " + sym->getName());
699 return sym->getName();
705 cantFail(file->getCOFFObj()->getSectionContents(header, a));
741 if (c->getSectionName() == name)
747 p2Align = std::max(p2Align, other->p2Align);
748 other->repl = repl;
749 other->live = false;
755 SectionRef s(r, file->getCOFFObj());
780 // should be 16-byte aligned. MSVC linker does this too.
787 write32le(buf + 2, impSymbol->getRVA() - rva - getSize());
791 res->emplace_back(getRVA() + 2, ctx.config.machine);
797 write32le(buf + 2, impSymbol->getRVA() + ctx.config.imageBase);
801 res->emplace_back(getRVA(), IMAGE_REL_BASED_ARM_MOV32T);
807 applyMOV32T(buf, impSymbol->getRVA() + ctx.config.imageBase);
811 int64_t off = impSymbol->getRVA() & 0xfff;
813 applyArm64Addr(buf, impSymbol->getRVA(), rva, 12);
817 // A Thumb2, PIC, non-interworking range extension thunk.
819 0x40, 0xf2, 0x00, 0x0c, // P: movw ip,:lower16:S - (P + (L1-P) + 4)
820 0xc0, 0xf2, 0x00, 0x0c, // movt ip,:upper16:S - (P + (L1-P) + 4)
825 assert(ctx.config.machine == ARMNT);
831 assert(ctx.config.machine == ARMNT);
832 uint64_t offset = target->getRVA() - rva - 12;
838 // +/- 4 GB, which is enough for any PE-COFF.
846 assert(ctx.config.machine == ARM64);
852 assert(ctx.config.machine == ARM64);
854 applyArm64Addr(buf + 0, target->getRVA(), rva, 12);
855 applyArm64Imm(buf + 4, target->getRVA() & 0xfff, 0);
860 setAlignment(ctx.config.wordsize);
864 res->emplace_back(getRVA(), ctx.config.machine);
867 size_t LocalImportChunk::getSize() const { return ctx.config.wordsize; }
870 if (ctx.config.is64()) {
871 write64le(buf, sym->getRVA() + ctx.config.imageBase);
873 write32le(buf, sym->getRVA() + ctx.config.imageBase);
881 begin[cnt++] = co.inputChunk->getRVA() + co.offset;
884 "RVA tables should be de-duplicated");
897 flag.rva = sym.inputChunk->getRVA() + sym.offset;
905 "RVA tables should be de-duplicated");
916 uint32_t start = entry.first->getRVA();
918 table[i].Length = entry.last->getRVA() + entry.last->getSize() - start;
943 table[idx + 0] = rpr.sym->getRVA();
944 table[idx + 1] = rpr.target->getRVA() + rpr.targetOffset;
950 // Windows-specific. This class represents a block in .reloc section.
953 // On Windows, each DLL is linked against a fixed base address and
955 // DLL that overlaps, the loader has to relocate it. To do that, DLLs
957 // up at runtime. If the loader finds that a DLL cannot be loaded to its
959 // base address> - <desired base address> to each offset that is
976 // 0x00000 -- page address (4 bytes)
977 // 16 -- size of this block (4 bytes)
978 // 0xA030 -- entries (2 bytes each)
982 // 0x20000 -- page address (4 bytes)
983 // 12 -- size of this block (4 bytes)
984 // 0xA004 -- entries (2 bytes each)
992 data.resize(alignTo((end - begin) * 2 + 8, 4));
998 write16le(p, (i->type << 12) | (i->rva - page));
1026 assert(isPowerOf2_32(c->getAlignment()));
1027 uint8_t p2Align = llvm::Log2_32(c->getAlignment());
1031 mc = make<MergeChunk>(c->getAlignment());
1032 mc->sections.push_back(c);
1038 if (c->live)
1039 builder.add(toStringRef(c->getContents()));
1046 if (!c->live)
1048 size_t off = builder.getOffset(toStringRef(c->getContents()));
1049 c->setRVA(rva + off);
1066 size_t AbsolutePointerChunk::getSize() const { return ctx.config.wordsize; }
1069 if (ctx.config.is64()) {