CbC/CbC_llvm: lld/MachO/UnwindInfoSection.cpp comparison

comparison lld/MachO/UnwindInfoSection.cpp @ 223:5f17cb93ff66 llvm-original

LLVM13 (2021/7/18)

author	Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date	Sun, 18 Jul 2021 22:43:00 +0900
parents	79ff65ed7e25
children	c4bab56944e8

comparison

equal deleted inserted replaced

-:81f6424ef0e3
+:5f17cb93ff66
 // here.
 // TODO(gkm): prune __eh_frame entries superseded by __unwind_info, PR50410
 // TODO(gkm): how do we align the 2nd-level pages?
-using EncodingMap = llvm::DenseMap<compact_unwind_encoding_t, size_t>;
+using EncodingMap = DenseMap<compact_unwind_encoding_t, size_t>;
 struct SecondLevelPage {
 uint32_t kind;
 size_t entryIndex;
 size_t entryCount;
 size_t byteCount;
 std::vector<compact_unwind_encoding_t> localEncodings;
 EncodingMap localEncodingIndexes;
 };
-template <class Ptr> class UnwindInfoSectionImpl : public UnwindInfoSection {
+template <class Ptr>
+class UnwindInfoSectionImpl final : public UnwindInfoSection {
 public:
-void prepareRelocations(InputSection *) override;
+void prepareRelocations(ConcatInputSection *) override;
+void addInput(ConcatInputSection *) override;
 void finalize() override;
 void writeTo(uint8_t *buf) const override;
 private:
 std::vector<std::pair<compact_unwind_encoding_t, size_t>> commonEncodings;
 SmallDenseMap<std::pair<InputSection *, uint64_t /* addend */>, Symbol *>
 personalityTable;
 std::vector<unwind_info_section_header_lsda_index_entry> lsdaEntries;
 // Map of function offset (from the image base) to an index within the LSDA
 // array.
-llvm::DenseMap<uint32_t, uint32_t> functionToLsdaIndex;
+DenseMap<uint32_t, uint32_t> functionToLsdaIndex;
 std::vector<CompactUnwindEntry<Ptr>> cuVector;
 std::vector<CompactUnwindEntry<Ptr> *> cuPtrVector;
 std::vector<SecondLevelPage> secondLevelPages;
 uint64_t level2PagesOffset = 0;
 };
+UnwindInfoSection::UnwindInfoSection()
+: SyntheticSection(segment_names::text, section_names::unwindInfo) {
+align = 4;
+compactUnwindSection =
+make<ConcatOutputSection>(section_names::compactUnwind);
+}
+void UnwindInfoSection::prepareRelocations() {
+for (ConcatInputSection *isec : compactUnwindSection->inputs)
+prepareRelocations(isec);
+}
+template <class Ptr>
+void UnwindInfoSectionImpl<Ptr>::addInput(ConcatInputSection *isec) {
+assert(isec->getSegName() == segment_names::ld &&
+isec->getName() == section_names::compactUnwind);
+isec->parent = compactUnwindSection;
+compactUnwindSection->addInput(isec);
+}
 // Compact unwind relocations have different semantics, so we handle them in a
 // separate code path from regular relocations. First, we do not wish to add
 // rebase opcodes for __LD,__compact_unwind, because that section doesn't
 // actually end up in the final binary. Second, personality pointers always
 // reside in the GOT and must be treated specially.
 template <class Ptr>
-void UnwindInfoSectionImpl<Ptr>::prepareRelocations(InputSection *isec) {
+void UnwindInfoSectionImpl<Ptr>::prepareRelocations(ConcatInputSection *isec) {
-assert(isec->segname == segment_names::ld &&
-isec->name == section_names::compactUnwind);
 assert(!isec->shouldOmitFromOutput() &&
 "__compact_unwind section should not be omitted");
-// FIXME: This could skip relocations for CompactUnwindEntries that
+// FIXME: Make this skip relocations for CompactUnwindEntries that
 // point to dead-stripped functions. That might save some amount of
 // work. But since there are usually just few personality functions
 // that are referenced from many places, at least some of them likely
 // live, it wouldn't reduce number of got entries.
-for (Reloc &r : isec->relocs) {
+for (size_t i = 0; i < isec->relocs.size(); ++i) {
+Reloc &r = isec->relocs[i];
 assert(target->hasAttr(r.type, RelocAttrBits::UNSIGNED));
+if (r.offset % sizeof(CompactUnwindEntry<Ptr>) == 0) {
+InputSection *referentIsec;
+if (auto *isec = r.referent.dyn_cast<InputSection *>())
+referentIsec = isec;
+else
+referentIsec = cast<Defined>(r.referent.dyn_cast<Symbol *>())->isec;
+if (!cast<ConcatInputSection>(referentIsec)->shouldOmitFromOutput())
+allEntriesAreOmitted = false;
+continue;
+}
 if (r.offset % sizeof(CompactUnwindEntry<Ptr>) !=
 offsetof(CompactUnwindEntry<Ptr>, personality))
 continue;
 if (auto *s = r.referent.dyn_cast<Symbol *>()) {
 in.got->addEntry(s);
 continue;
 }
 if (auto *referentIsec = r.referent.dyn_cast<InputSection *>()) {
-assert(!referentIsec->isCoalescedWeak());
+assert(!isCoalescedWeak(referentIsec));
 // Personality functions can be referenced via section relocations
 // if they live in the same object file. Create placeholder synthetic
 // symbols for them in the GOT.
 Symbol *&s = personalityTable[{referentIsec, r.addend}];
 if (s == nullptr) {
 // Unwind info lives in __DATA, and finalization of __TEXT will occur before
 // finalization of __DATA. Moreover, the finalization of unwind info depends on
 // the exact addresses that it references. So it is safe for compact unwind to
 // reference addresses in __TEXT, but not addresses in any other segment.
-static void checkTextSegment(InputSection *isec) {
+static ConcatInputSection *checkTextSegment(InputSection *isec) {
-if (isec->segname != segment_names::text)
+if (isec->getSegName() != segment_names::text)
 error("compact unwind references address in " + toString(isec) +
 " which is not in segment __TEXT");
-}
+// __text should always be a ConcatInputSection.
+return cast<ConcatInputSection>(isec);
+}
+template <class Ptr>
+constexpr Ptr TombstoneValue = std::numeric_limits<Ptr>::max();
 // We need to apply the relocations to the pre-link compact unwind section
 // before converting it to post-link form. There should only be absolute
 // relocations here: since we are not emitting the pre-link CU section, there
 // is no source address to make a relative location meaningful.
 template <class Ptr>
 static void
 relocateCompactUnwind(ConcatOutputSection *compactUnwindSection,
 std::vector<CompactUnwindEntry<Ptr>> &cuVector) {
-for (const InputSection *isec : compactUnwindSection->inputs) {
+for (const ConcatInputSection *isec : compactUnwindSection->inputs) {
 assert(isec->parent == compactUnwindSection);
 uint8_t *buf =
-reinterpret_cast<uint8_t *>(cuVector.data()) + isec->outSecFileOff;
+reinterpret_cast<uint8_t *>(cuVector.data()) + isec->outSecOff;
 memcpy(buf, isec->data.data(), isec->data.size());
 for (const Reloc &r : isec->relocs) {
-uint64_t referentVA = 0;
+uint64_t referentVA = TombstoneValue<Ptr>;
 if (auto *referentSym = r.referent.dyn_cast<Symbol *>()) {
 if (!isa<Undefined>(referentSym)) {
-assert(referentSym->isInGot());
 if (auto *defined = dyn_cast<Defined>(referentSym))
 checkTextSegment(defined->isec);
 // At this point in the link, we may not yet know the final address of
 // the GOT, so we just encode the index. We make it a 1-based index so
 // that we can distinguish the null pointer case.
 referentVA = referentSym->gotIndex + 1;
 }
-} else if (auto *referentIsec = r.referent.dyn_cast<InputSection *>()) {
+} else {
-checkTextSegment(referentIsec);
+auto *referentIsec = r.referent.get<InputSection *>();
-if (referentIsec->shouldOmitFromOutput())
+ConcatInputSection *concatIsec = checkTextSegment(referentIsec);
-referentVA = UINT64_MAX; // Tombstone value
+if (!concatIsec->shouldOmitFromOutput())
-else
+referentVA = referentIsec->getVA(r.addend);
-referentVA = referentIsec->getVA() + r.addend;
 }
 writeAddress(buf + r.offset, referentVA, r.length);
 }
 }
 }
 // There should only be a handful of unique personality pointers, so we can
 // encode them as 2-bit indices into a small array.
 template <class Ptr>
-void encodePersonalities(
+static void
-const std::vector<CompactUnwindEntry<Ptr> *> &cuPtrVector,
+encodePersonalities(const std::vector<CompactUnwindEntry<Ptr> *> &cuPtrVector,
 std::vector<uint32_t> &personalities) {
 for (CompactUnwindEntry<Ptr> *cu : cuPtrVector) {
 if (cu->personality == 0)
 continue;
 // Linear search is fast enough for a small array.
 auto it = find(personalities, cu->personality);
 static_cast<compact_unwind_encoding_t>(UNWIND_PERSONALITY_MASK));
 }
 if (personalities.size() > 3)
 error("too many personalities (" + std::to_string(personalities.size()) +
 ") for compact unwind to encode");
+}
+// __unwind_info stores unwind data for address ranges. If several
+// adjacent functions have the same unwind encoding, LSDA, and personality
+// function, they share one unwind entry. For this to work, functions without
+// unwind info need explicit "no unwind info" unwind entries -- else the
+// unwinder would think they have the unwind info of the closest function
+// with unwind info right before in the image.
+template <class Ptr>
+static void addEntriesForFunctionsWithoutUnwindInfo(
+std::vector<CompactUnwindEntry<Ptr>> &cuVector) {
+DenseSet<Ptr> hasUnwindInfo;
+for (CompactUnwindEntry<Ptr> &cuEntry : cuVector)
+if (cuEntry.functionAddress != TombstoneValue<Ptr>)
+hasUnwindInfo.insert(cuEntry.functionAddress);
+// Add explicit "has no unwind info" entries for all global and local symbols
+// without unwind info.
+auto markNoUnwindInfo = [&cuVector, &hasUnwindInfo](const Defined *d) {
+if (d->isLive() && d->isec && isCodeSection(d->isec)) {
+Ptr ptr = d->getVA();
+if (!hasUnwindInfo.count(ptr))
+cuVector.push_back({ptr, 0, 0, 0, 0});
+}
+};
+for (Symbol *sym : symtab->getSymbols())
+if (auto *d = dyn_cast<Defined>(sym))
+markNoUnwindInfo(d);
+for (const InputFile *file : inputFiles)
+if (auto *objFile = dyn_cast<ObjFile>(file))
+for (Symbol *sym : objFile->symbols)
+if (auto *d = dyn_cast_or_null<Defined>(sym))
+if (!d->isExternal())
+markNoUnwindInfo(d);
+}
+static bool canFoldEncoding(compact_unwind_encoding_t encoding) {
+// From compact_unwind_encoding.h:
+//  UNWIND_X86_64_MODE_STACK_IND:
+//  A "frameless" (RBP not used as frame pointer) function large constant
+//  stack size.  This case is like the previous, except the stack size is too
+//  large to encode in the compact unwind encoding.  Instead it requires that
+//  the function contains "subq $nnnnnnnn,RSP" in its prolog.  The compact
+//  encoding contains the offset to the nnnnnnnn value in the function in
+//  UNWIND_X86_64_FRAMELESS_STACK_SIZE.
+// Since this means the unwinder has to look at the `subq` in the function
+// of the unwind info's unwind address, two functions that have identical
+// unwind info can't be folded if it's using this encoding since both
+// entries need unique addresses.
+static_assert(UNWIND_X86_64_MODE_MASK == UNWIND_X86_MODE_MASK, "");
+static_assert(UNWIND_X86_64_MODE_STACK_IND == UNWIND_X86_MODE_STACK_IND, "");
+if ((target->cpuType == CPU_TYPE_X86_64 || target->cpuType == CPU_TYPE_X86) &&
+(encoding & UNWIND_X86_64_MODE_MASK) == UNWIND_X86_64_MODE_STACK_IND) {
+// FIXME: Consider passing in the two function addresses and getting
+// their two stack sizes off the `subq` and only returning false if they're
+// actually different.
+return false;
+}
+return true;
 }
 // Scan the __LD,__compact_unwind entries and compute the space needs of
 // __TEXT,__unwind_info and __TEXT,__eh_frame
 template <class Ptr> void UnwindInfoSectionImpl<Ptr>::finalize() {
 size_t cuCount =
 compactUnwindSection->getSize() / sizeof(CompactUnwindEntry<Ptr>);
 cuVector.resize(cuCount);
 relocateCompactUnwind(compactUnwindSection, cuVector);
+addEntriesForFunctionsWithoutUnwindInfo(cuVector);
 // Rather than sort & fold the 32-byte entries directly, we create a
 // vector of pointers to entries and sort & fold that instead.
-cuPtrVector.reserve(cuCount);
+cuPtrVector.reserve(cuVector.size());
 for (CompactUnwindEntry<Ptr> &cuEntry : cuVector)
 cuPtrVector.emplace_back(&cuEntry);
 llvm::sort(cuPtrVector, [](const CompactUnwindEntry<Ptr> *a,
 const CompactUnwindEntry<Ptr> *b) {
 return a->functionAddress < b->functionAddress;
 });
-// Dead-stripped functions get a functionAddress of UINT64_MAX in
+// Dead-stripped functions get a functionAddress of TombstoneValue in
 // relocateCompactUnwind(). Filter them out here.
 // FIXME: This doesn't yet collect associated data like LSDAs kept
 // alive only by a now-removed CompactUnwindEntry or other comdat-like
 // data (`kindNoneGroupSubordinate*` in ld64).
 CompactUnwindEntry<Ptr> tombstone;
-tombstone.functionAddress = static_cast<Ptr>(UINT64_MAX);
+tombstone.functionAddress = TombstoneValue<Ptr>;
 cuPtrVector.erase(
 std::lower_bound(cuPtrVector.begin(), cuPtrVector.end(), &tombstone,
 [](const CompactUnwindEntry<Ptr> *a,
 const CompactUnwindEntry<Ptr> *b) {
 return a->functionAddress < b->functionAddress;
 }),
 cuPtrVector.end());
+// If there are no entries left after adding explicit "no unwind info"
+// entries and removing entries for dead-stripped functions, don't write
+// an __unwind_info section at all.
+assert(allEntriesAreOmitted == cuPtrVector.empty());
+if (cuPtrVector.empty())
+return;
 // Fold adjacent entries with matching encoding+personality+lsda
 // We use three iterators on the same cuPtrVector to fold in-situ:
 // (1) `foldBegin` is the first of a potential sequence of matching entries
 // (2) `foldEnd` is the first non-matching entry after `foldBegin`.
 for (auto foldBegin = cuPtrVector.begin(); foldBegin < cuPtrVector.end();) {
 auto foldEnd = foldBegin;
 while (++foldEnd < cuPtrVector.end() &&
 (*foldBegin)->encoding == (*foldEnd)->encoding &&
 (*foldBegin)->personality == (*foldEnd)->personality &&
-(*foldBegin)->lsda == (*foldEnd)->lsda)
+(*foldBegin)->lsda == (*foldEnd)->lsda &&
+canFoldEncoding((*foldEnd)->encoding))
 ;
 *foldWrite++ = *foldBegin;
 foldBegin = foldEnd;
 }
 cuPtrVector.erase(foldWrite, cuPtrVector.end());
 // All inputs are relocated and output addresses are known, so write!
 template <class Ptr>
 void UnwindInfoSectionImpl<Ptr>::writeTo(uint8_t *buf) const {
+assert(!cuPtrVector.empty() && "call only if there is unwind info");
 // section header
 auto *uip = reinterpret_cast<unwind_info_section_header *>(buf);
 uip->version = 1;
 uip->commonEncodingsArraySectionOffset = sizeof(unwind_info_section_header);
 uip->commonEncodingsArrayCount = commonEncodings.size();
 sizeof(unwind_info_section_header_lsda_index_entry);
 iep++;
 l2PagesOffset += SECOND_LEVEL_PAGE_BYTES;
 }
 // Level-1 sentinel
-const CompactUnwindEntry<Ptr> &cuEnd = cuVector.back();
+const CompactUnwindEntry<Ptr> &cuEnd = *cuPtrVector.back();
-iep->functionOffset = cuEnd.functionAddress + cuEnd.functionLength;
+assert(cuEnd.functionAddress != TombstoneValue<Ptr>);
+iep->functionOffset =
+cuEnd.functionAddress - in.header->addr + cuEnd.functionLength;
 iep->secondLevelPagesSectionOffset = 0;
 iep->lsdaIndexArraySectionOffset =
 lsdaOffset +
 lsdaEntries.size() * sizeof(unwind_info_section_header_lsda_index_entry);
 iep++;

Mercurial > hg > CbC > CbC_llvm

comparison lld/MachO/UnwindInfoSection.cpp @ 223:5f17cb93ff66 llvm-original