Merge remote-tracking branch 'origin/master' into master-rebranch

Author: jckarter

include/swift/Reflection/ReflectionContext.h

@@ -30,7 +30,6 @@
 #include "swift/Reflection/TypeRef.h"
 #include "swift/Reflection/TypeRefBuilder.h"
 #include "swift/Runtime/Unreachable.h"
-#include "../../../stdlib/public/runtime/ImageInspectionELF.h"
 
 #include <iostream>
 #include <set>
@@ -60,15 +59,15 @@ template <unsigned char ELFClass> struct ELFTraits;
 
 template <> struct ELFTraits<llvm::ELF::ELFCLASS32> {
   using Header = const struct llvm::ELF::Elf32_Ehdr;
-  using ProgramHeader = const struct llvm::ELF::Elf32_Phdr;
+  using Section = const struct llvm::ELF::Elf32_Shdr;
   using Offset = llvm::ELF::Elf32_Off;
   using Size = llvm::ELF::Elf32_Word;
   static constexpr unsigned char ELFClass = llvm::ELF::ELFCLASS32;
 };
 
 template <> struct ELFTraits<llvm::ELF::ELFCLASS64> {
   using Header = const struct llvm::ELF::Elf64_Ehdr;
-  using ProgramHeader = const struct llvm::ELF::Elf64_Phdr;
+  using Section = const struct llvm::ELF::Elf64_Shdr;
   using Offset = llvm::ELF::Elf64_Off;
   using Size = llvm::ELF::Elf64_Xword;
   static constexpr unsigned char ELFClass = llvm::ELF::ELFCLASS64;
@@ -113,7 +112,7 @@ class ReflectionContext
 
   ReflectionContext(const ReflectionContext &other) = delete;
   ReflectionContext &operator=(const ReflectionContext &other) = delete;
-
+  
   MemoryReader &getReader() {
     return *this->Reader;
   }
@@ -196,9 +195,9 @@ class ReflectionContext
       // introduce misaligned pointers mapping between local and remote
       // address space.
       RangeStart = RangeStart & ~7;
-      RangeEnd = RangeEnd + 7 & ~7;
+      RangeEnd = RangeEnd + 7 & ~7;      
     }
-
+ 
     if (RangeStart == UINT64_MAX && RangeEnd == UINT64_MAX)
       return false;
 
@@ -238,18 +237,13 @@ class ReflectionContext
         ReflStrMdSec.first == nullptr)
       return false;
 
-    auto LocalStartAddress = reinterpret_cast<uint64_t>(SectBuf.get());
-    auto RemoteStartAddress = static_cast<uint64_t>(RangeStart);
-
     ReflectionInfo info = {
         {FieldMdSec.first, FieldMdSec.second},
         {AssocTySec.first, AssocTySec.second},
         {BuiltinTySec.first, BuiltinTySec.second},
         {CaptureSec.first, CaptureSec.second},
         {TypeRefMdSec.first, TypeRefMdSec.second},
-        {ReflStrMdSec.first, ReflStrMdSec.second},
-        LocalStartAddress,
-        RemoteStartAddress};
+        {ReflStrMdSec.first, ReflStrMdSec.second}};
 
     this->addReflectionInfo(info);
 
@@ -347,19 +341,13 @@ class ReflectionContext
         ReflStrMdSec.first == nullptr)
       return false;
 
-    auto LocalStartAddress = reinterpret_cast<uintptr_t>(DOSHdrBuf.get());
-    auto RemoteStartAddress =
-        static_cast<uintptr_t>(ImageStart.getAddressData());
-
     ReflectionInfo Info = {
         {FieldMdSec.first, FieldMdSec.second},
         {AssocTySec.first, AssocTySec.second},
         {BuiltinTySec.first, BuiltinTySec.second},
         {CaptureSec.first, CaptureSec.second},
         {TypeRefMdSec.first, TypeRefMdSec.second},
-        {ReflStrMdSec.first, ReflStrMdSec.second},
-        LocalStartAddress,
-        RemoteStartAddress};
+        {ReflStrMdSec.first, ReflStrMdSec.second}};
     this->addReflectionInfo(Info);
     return true;
   }
@@ -387,105 +375,110 @@ class ReflectionContext
   }
 
   template <typename T> bool readELFSections(RemoteAddress ImageStart) {
-    auto HeaderBuf =
+    auto Buf =
         this->getReader().readBytes(ImageStart, sizeof(typename T::Header));
 
-    auto Hdr = reinterpret_cast<const typename T::Header *>(HeaderBuf.get());
+    auto Hdr = reinterpret_cast<const typename T::Header *>(Buf.get());
     assert(Hdr->getFileClass() == T::ELFClass && "invalid ELF file class");
 
-    const auto ProgramHdrAddress = ImageStart.getAddressData() + Hdr->e_phoff;
-    const auto NumEntries = Hdr->e_phnum;
-    const auto EntrySize = Hdr->e_phentsize;
-
-    uintptr_t MetadataSectionsPtrValue = 0;
-    for (unsigned I = 0; I < NumEntries; ++I) {
-      const StringRef MagicString =
-          SWIFT_REFLECTION_METADATA_ELF_NOTE_MAGIC_STRING;
-      auto ProgramHdrBuf = this->getReader().readBytes(
-          RemoteAddress(ProgramHdrAddress + (I * EntrySize)), EntrySize);
-      auto ProgramHdr = reinterpret_cast<const typename T::ProgramHeader *>(
-          ProgramHdrBuf.get());
-      if (ProgramHdr->p_type != llvm::ELF::PT_NOTE ||
-          ProgramHdr->p_memsz <= MagicString.size())
-        continue;
-      const auto SegmentAddr =
-          ImageStart.getAddressData() + ProgramHdr->p_vaddr;
-      const auto SegmentSize = ProgramHdr->p_memsz;
-      auto SegmentBuf =
-          this->getReader().readBytes(RemoteAddress(SegmentAddr), SegmentSize);
-      const char *SegmentData =
-          reinterpret_cast<const char *>(SegmentBuf.get());
-      if (!StringRef(SegmentData, SegmentSize).startswith(MagicString))
-        continue;
-      MetadataSectionsPtrValue = *reinterpret_cast<const uintptr_t *>(
-          SegmentData + MagicString.size() + 1);
-      break;
+    // From the header, grab informations about the section header table.
+    auto SectionHdrAddress = ImageStart.getAddressData() + Hdr->e_shoff;
+    auto SectionHdrNumEntries = Hdr->e_shnum;
+    auto SectionEntrySize = Hdr->e_shentsize;
+
+    // Collect all the section headers, we need them to look up the
+    // reflection sections (by name) and the string table.
+    std::vector<const typename T::Section *> SecHdrVec;
+    for (unsigned I = 0; I < SectionHdrNumEntries; ++I) {
+      auto SecBuf = this->getReader().readBytes(
+          RemoteAddress(SectionHdrAddress + (I * SectionEntrySize)),
+          SectionEntrySize);
+      auto SecHdr =
+          reinterpret_cast<const typename T::Section *>(SecBuf.get());
+      SecHdrVec.push_back(SecHdr);
     }
-    if (!MetadataSectionsPtrValue)
-      return false;
 
-    auto MetadataSectionsStructBuf = this->getReader().readBytes(
-        RemoteAddress(MetadataSectionsPtrValue), sizeof(MetadataSections));
-    const auto *Sections = reinterpret_cast<const MetadataSections *>(
-        MetadataSectionsStructBuf.get());
-
-    auto BeginAddr = std::min(
-        {Sections->swift5_fieldmd.start, Sections->swift5_assocty.start,
-         Sections->swift5_builtin.start, Sections->swift5_capture.start,
-         Sections->swift5_typeref.start, Sections->swift5_reflstr.start});
-    auto EndAddr = std::max({
-        Sections->swift5_fieldmd.start + Sections->swift5_fieldmd.length,
-        Sections->swift5_assocty.start + Sections->swift5_assocty.length,
-        Sections->swift5_builtin.start + Sections->swift5_builtin.length,
-        Sections->swift5_capture.start + Sections->swift5_capture.length,
-        Sections->swift5_typeref.start + Sections->swift5_typeref.length,
-        Sections->swift5_reflstr.start + Sections->swift5_reflstr.length,
-    });
-
-    // Extend the range [BeginAddr, EndAddr) to include the data segments.
-    for (unsigned I = 0; I < NumEntries; ++I) {
-      auto ProgramHdrBuf = this->getReader().readBytes(
-          RemoteAddress(ProgramHdrAddress + (I * EntrySize)), EntrySize);
-      auto ProgramHdr = reinterpret_cast<const typename T::ProgramHeader *>(
-          ProgramHdrBuf.get());
-      if (ProgramHdr->p_type == llvm::ELF::PT_LOAD &&
-          ProgramHdr->p_flags & (llvm::ELF::PF_W & llvm::ELF::PF_R)) {
-        const decltype(BeginAddr) SegmentBeginAddr =
-            ImageStart.getAddressData() + ProgramHdr->p_vaddr;
-        const decltype(BeginAddr) SegmentEndAddr =
-            SegmentBeginAddr + ProgramHdr->p_memsz;
-        BeginAddr = std::min(BeginAddr, SegmentBeginAddr);
-        EndAddr = std::max(EndAddr, SegmentEndAddr);
-      }
+    // This provides quick access to the section header string table index.
+    // We also here handle the unlikely even where the section index overflows
+    // and it's just a pointer to secondary storage (SHN_XINDEX).
+    uint32_t SecIdx = Hdr->e_shstrndx;
+    if (SecIdx == llvm::ELF::SHN_XINDEX) {
+      assert(!SecHdrVec.empty() && "malformed ELF object");
+      SecIdx = SecHdrVec[0]->sh_link;
     }
 
-    auto Buf = this->getReader().readBytes(RemoteAddress(BeginAddr),
-                                           EndAddr - BeginAddr);
-    auto RemoteAddrToRemoteRef = [&](uintptr_t Addr) -> RemoteRef<void> {
-      return RemoteRef<void>(
-          Addr, reinterpret_cast<void *>(
-                    reinterpret_cast<uintptr_t>(Buf.get()) + Addr - BeginAddr));
+    assert(SecIdx < SecHdrVec.size() && "malformed ELF object");
+
+    const typename T::Section *SecHdrStrTab = SecHdrVec[SecIdx];
+    typename T::Offset StrTabOffset = SecHdrStrTab->sh_offset;
+    typename T::Size StrTabSize = SecHdrStrTab->sh_size;
+
+    auto StrTabStart =
+        RemoteAddress(ImageStart.getAddressData() + StrTabOffset);
+    auto StrTabBuf = this->getReader().readBytes(StrTabStart, StrTabSize);
+    auto StrTab = reinterpret_cast<const char *>(StrTabBuf.get());
+
+    auto findELFSectionByName = [&](std::string Name)
+        -> std::pair<RemoteRef<void>, uint64_t> {
+      // Now for all the sections, find their name.
+      for (const typename T::Section *Hdr : SecHdrVec) {
+        uint32_t Offset = Hdr->sh_name;
+        auto SecName = std::string(StrTab + Offset);
+        if (SecName != Name)
+          continue;
+        auto SecStart =
+            RemoteAddress(ImageStart.getAddressData() + Hdr->sh_addr);
+        auto SecSize = Hdr->sh_size;
+        auto SecBuf = this->getReader().readBytes(SecStart, SecSize);
+        auto SecContents = RemoteRef<void>(SecStart.getAddressData(),
+                                           SecBuf.get());
+        savedBuffers.push_back(std::move(SecBuf));
+        return {SecContents, SecSize};
+      }
+      return {nullptr, 0};
     };
-#define SECTION_INFO(NAME)                                                     \
-  {RemoteAddrToRemoteRef(Sections->NAME.start), Sections->NAME.length}
-    ReflectionInfo Info = {
-        SECTION_INFO(swift5_fieldmd),          SECTION_INFO(swift5_assocty),
-        SECTION_INFO(swift5_builtin),          SECTION_INFO(swift5_capture),
-        SECTION_INFO(swift5_typeref),          SECTION_INFO(swift5_reflstr),
-        reinterpret_cast<uint64_t>(Buf.get()), BeginAddr};
-#undef SECTION_INFO
-    this->addReflectionInfo(Info);
+
+    auto FieldMdSec = findELFSectionByName("swift5_fieldmd");
+    auto AssocTySec = findELFSectionByName("swift5_assocty");
+    auto BuiltinTySec = findELFSectionByName("swift5_builtin");
+    auto CaptureSec = findELFSectionByName("swift5_capture");
+    auto TypeRefMdSec = findELFSectionByName("swift5_typeref");
+    auto ReflStrMdSec = findELFSectionByName("swift5_reflstr");
+
+    // We succeed if at least one of the sections is present in the
+    // ELF executable.
+    if (FieldMdSec.first == nullptr &&
+        AssocTySec.first == nullptr &&
+        BuiltinTySec.first == nullptr &&
+        CaptureSec.first == nullptr &&
+        TypeRefMdSec.first == nullptr &&
+        ReflStrMdSec.first == nullptr)
+      return false;
+
+    ReflectionInfo info = {
+        {FieldMdSec.first, FieldMdSec.second},
+        {AssocTySec.first, AssocTySec.second},
+        {BuiltinTySec.first, BuiltinTySec.second},
+        {CaptureSec.first, CaptureSec.second},
+        {TypeRefMdSec.first, TypeRefMdSec.second},
+        {ReflStrMdSec.first, ReflStrMdSec.second}};
+
+    this->addReflectionInfo(info);
+
     savedBuffers.push_back(std::move(Buf));
     return true;
   }
-
+         
   bool readELF(RemoteAddress ImageStart) {
     auto Buf =
         this->getReader().readBytes(ImageStart, sizeof(llvm::ELF::Elf64_Ehdr));
+
     // Read the header.
     auto Hdr = reinterpret_cast<const llvm::ELF::Elf64_Ehdr *>(Buf.get());
+
     if (!Hdr->checkMagic())
       return false;
+
     // Check if we have a ELFCLASS32 or ELFCLASS64
     unsigned char FileClass = Hdr->getFileClass();
     if (FileClass == llvm::ELF::ELFCLASS64) {
@@ -502,34 +495,34 @@ class ReflectionContext
     auto Magic = this->getReader().readBytes(ImageStart, sizeof(uint32_t));
     if (!Magic)
       return false;
-
+    
     uint32_t MagicWord;
     memcpy(&MagicWord, Magic.get(), sizeof(MagicWord));
-
+    
     // 32- and 64-bit Mach-O.
     if (MagicWord == llvm::MachO::MH_MAGIC) {
       return readMachOSections<MachOTraits<4>>(ImageStart);
     }
-
+    
     if (MagicWord == llvm::MachO::MH_MAGIC_64) {
       return readMachOSections<MachOTraits<8>>(ImageStart);
     }
-
+    
     // PE. (This just checks for the DOS header; `readPECOFF` will further
     // validate the existence of the PE header.)
     auto MagicBytes = (const char*)Magic.get();
     if (MagicBytes[0] == 'M' && MagicBytes[1] == 'Z') {
       return readPECOFF(ImageStart);
     }
-
+    
     // ELF.
     if (MagicBytes[0] == llvm::ELF::ElfMagic[0]
         && MagicBytes[1] == llvm::ELF::ElfMagic[1]
         && MagicBytes[2] == llvm::ELF::ElfMagic[2]
         && MagicBytes[3] == llvm::ELF::ElfMagic[3]) {
       return readELF(ImageStart);
     }
-
+    
     // We don't recognize the format.
     return false;
   }
@@ -544,7 +537,7 @@ class ReflectionContext
       return true;
     return ownsAddress(RemoteAddress(*MetadataAddress));
   }
-
+  
   /// Returns true if the address falls within a registered image.
   bool ownsAddress(RemoteAddress Address) {
     for (auto Range : imageRanges) {
@@ -554,10 +547,10 @@ class ReflectionContext
           && Address.getAddressData() < End.getAddressData())
         return true;
     }
-
+  
     return false;
   }
-
+  
   /// Return a description of the layout of a class instance with the given
   /// metadata as its isa pointer.
   const TypeInfo *getMetadataTypeInfo(StoredPointer MetadataAddress) {

include/swift/Reflection/TypeRefBuilder.h

@@ -203,9 +203,6 @@ struct ReflectionInfo {
   CaptureSection Capture;
   GenericSection TypeReference;
   GenericSection ReflectionString;
-
-  uint64_t LocalStartAddress;
-  uint64_t RemoteStartAddress;
 };
 
 struct ClosureContextInfo {

lib/Demangling/NodePrinter.cpp

@@ -79,19 +79,18 @@ static DemanglerPrinter &operator<<(DemanglerPrinter &printer,
     case '\n': printer << "\\n"; break;
     case '\r': printer << "\\r"; break;
     case '"': printer << "\\\""; break;
-    case '\'': printer << '\''; break; // no need to escape these
     case '\0': printer << "\\0"; break;
     default:
-      auto c = static_cast<char>(C);
-      // Other ASCII control characters should get escaped.
-      if (c < 0x20 || c == 0x7F) {
+      auto c = static_cast<unsigned char>(C);
+      // Other control or high-bit characters should get escaped.
+      if (c < 0x20 || c >= 0x7F) {
         static const char Hexdigit[] = {
           '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
           'A', 'B', 'C', 'D', 'E', 'F'
         };
         printer << "\\x" << Hexdigit[c >> 4] << Hexdigit[c & 0xF];
       } else {
-        printer << c;
+        printer << (char)c;
       }
       break;
     }

stdlib/public/Reflection/TypeRefBuilder.cpp

@@ -268,15 +268,13 @@ TypeRefBuilder::getBuiltinTypeInfo(const TypeRef *TR) {
   return nullptr;
 }
 
-// TODO: This can probably be eliminated.
 RemoteRef<CaptureDescriptor>
 TypeRefBuilder::getCaptureDescriptor(uint64_t RemoteAddress) {
   for (auto Info : ReflectionInfos) {
     for (auto CD : Info.Capture) {
-      auto OtherAddr = (reinterpret_cast<uint64_t>(CD.getLocalBuffer()) -
-                        Info.LocalStartAddress + Info.RemoteStartAddress);
-      if (OtherAddr == RemoteAddress)
+      if (RemoteAddress == CD.getAddressData()) {
         return CD;
+      }
     }
   }