================ @@ -0,0 +1,2001 @@ +//===--- APINotesReader.cpp - API Notes Reader ------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "clang/APINotes/APINotesReader.h" +#include "APINotesFormat.h" +#include "llvm/ADT/Hashing.h" +#include "llvm/ADT/StringExtras.h" +#include "llvm/Bitstream/BitstreamReader.h" +#include "llvm/Support/DJB.h" +#include "llvm/Support/EndianStream.h" +#include "llvm/Support/OnDiskHashTable.h" + +namespace clang { +namespace api_notes { +using namespace llvm::support; + +namespace { +/// Deserialize a version tuple. +llvm::VersionTuple ReadVersionTuple(const uint8_t *&Data) { + uint8_t NumVersions = (*Data++) & 0x03; + + unsigned Major = endian::readNext<uint32_t, little, unaligned>(Data); + if (NumVersions == 0) + return llvm::VersionTuple(Major); + + unsigned Minor = endian::readNext<uint32_t, little, unaligned>(Data); + if (NumVersions == 1) + return llvm::VersionTuple(Major, Minor); + + unsigned Subminor = endian::readNext<uint32_t, little, unaligned>(Data); + if (NumVersions == 2) + return llvm::VersionTuple(Major, Minor, Subminor); + + unsigned Build = endian::readNext<uint32_t, little, unaligned>(Data); + return llvm::VersionTuple(Major, Minor, Subminor, Build); +} + +/// An on-disk hash table whose data is versioned based on the Swift version. +template <typename Derived, typename KeyType, typename UnversionedDataType> +class VersionedTableInfo { +public: + using internal_key_type = KeyType; + using external_key_type = KeyType; + using data_type = + llvm::SmallVector<std::pair<llvm::VersionTuple, UnversionedDataType>, 1>; + using hash_value_type = size_t; + using offset_type = unsigned; + + internal_key_type GetInternalKey(external_key_type Key) { return Key; } + + external_key_type GetExternalKey(internal_key_type Key) { return Key; } + + static bool EqualKey(internal_key_type LHS, internal_key_type RHS) { + return LHS == RHS; + } + + static std::pair<unsigned, unsigned> ReadKeyDataLength(const uint8_t *&Data) { + unsigned KeyLength = endian::readNext<uint16_t, little, unaligned>(Data); + unsigned DataLength = endian::readNext<uint16_t, little, unaligned>(Data); + return {KeyLength, DataLength}; + } + + static data_type ReadData(internal_key_type Key, const uint8_t *Data, + unsigned Length) { + unsigned NumElements = endian::readNext<uint16_t, little, unaligned>(Data); + data_type Result; + Result.reserve(NumElements); + for (unsigned i = 0; i != NumElements; ++i) { + auto version = ReadVersionTuple(Data); + const auto *DataBefore = Data; + (void)DataBefore; + auto UnversionedData = Derived::readUnversioned(Key, Data); + assert(Data != DataBefore && + "Unversioned data reader didn't move pointer"); + Result.push_back({version, UnversionedData}); + } + return Result; + } +}; + +/// Read serialized CommonEntityInfo. +void ReadCommonEntityInfo(const uint8_t *&Data, CommonEntityInfo &Info) { + uint8_t UnavailableBits = *Data++; + Info.Unavailable = (UnavailableBits >> 1) & 0x01; + Info.UnavailableInSwift = UnavailableBits & 0x01; + if ((UnavailableBits >> 2) & 0x01) + Info.setSwiftPrivate(static_cast<bool>((UnavailableBits >> 3) & 0x01)); + + unsigned MsgLength = endian::readNext<uint16_t, little, unaligned>(Data); + Info.UnavailableMsg = + std::string(reinterpret_cast<const char *>(Data), + reinterpret_cast<const char *>(Data) + MsgLength); + Data += MsgLength; + + unsigned SwiftNameLength = + endian::readNext<uint16_t, little, unaligned>(Data); + Info.SwiftName = + std::string(reinterpret_cast<const char *>(Data), + reinterpret_cast<const char *>(Data) + SwiftNameLength); + Data += SwiftNameLength; +} + +/// Read serialized CommonTypeInfo. +void ReadCommonTypeInfo(const uint8_t *&Data, CommonTypeInfo &Info) { + ReadCommonEntityInfo(Data, Info); + + unsigned SwiftBridgeLength = + endian::readNext<uint16_t, little, unaligned>(Data); + if (SwiftBridgeLength > 0) { + Info.setSwiftBridge(std::optional<std::string>(std::string( + reinterpret_cast<const char *>(Data), SwiftBridgeLength - 1))); + Data += SwiftBridgeLength - 1; + } + + unsigned ErrorDomainLength = + endian::readNext<uint16_t, little, unaligned>(Data); + if (ErrorDomainLength > 0) { + Info.setNSErrorDomain(std::optional<std::string>(std::string( + reinterpret_cast<const char *>(Data), ErrorDomainLength - 1))); + Data += ErrorDomainLength - 1; + } +} + +/// Used to deserialize the on-disk identifier table. +class IdentifierTableInfo { +public: + using internal_key_type = llvm::StringRef; + using external_key_type = llvm::StringRef; + using data_type = IdentifierID; + using hash_value_type = uint32_t; + using offset_type = unsigned; + + internal_key_type GetInternalKey(external_key_type Key) { return Key; } + + external_key_type GetExternalKey(internal_key_type Key) { return Key; } + + hash_value_type ComputeHash(internal_key_type Key) { + return llvm::djbHash(Key); + } + + static bool EqualKey(internal_key_type LHS, internal_key_type RHS) { + return LHS == RHS; + } + + static std::pair<unsigned, unsigned> ReadKeyDataLength(const uint8_t *&Data) { + unsigned KeyLength = endian::readNext<uint16_t, little, unaligned>(Data); + unsigned DataLength = endian::readNext<uint16_t, little, unaligned>(Data); + return {KeyLength, DataLength}; + } + + static internal_key_type ReadKey(const uint8_t *Data, unsigned Length) { + return llvm::StringRef(reinterpret_cast<const char *>(Data), Length); + } + + static data_type ReadData(internal_key_type key, const uint8_t *Data, + unsigned Length) { + return endian::readNext<uint32_t, little, unaligned>(Data); + } +}; + +/// Used to deserialize the on-disk Objective-C class table. +class ObjCContextIDTableInfo { +public: + using internal_key_type = ContextTableKey; + using external_key_type = internal_key_type; + using data_type = unsigned; + using hash_value_type = size_t; + using offset_type = unsigned; + + internal_key_type GetInternalKey(external_key_type Key) { return Key; } + + external_key_type GetExternalKey(internal_key_type Key) { return Key; } + + hash_value_type ComputeHash(internal_key_type Key) { + return static_cast<size_t>(Key.hashValue()); + } + + static bool EqualKey(internal_key_type LHS, internal_key_type RHS) { + return LHS == RHS; + } + + static std::pair<unsigned, unsigned> ReadKeyDataLength(const uint8_t *&Data) { + unsigned KeyLength = endian::readNext<uint16_t, little, unaligned>(Data); + unsigned DataLength = endian::readNext<uint16_t, little, unaligned>(Data); + return {KeyLength, DataLength}; + } + + static internal_key_type ReadKey(const uint8_t *Data, unsigned Length) { + auto ParentCtxID = endian::readNext<uint32_t, little, unaligned>(Data); + auto ContextKind = endian::readNext<uint8_t, little, unaligned>(Data); + auto NameID = endian::readNext<uint32_t, little, unaligned>(Data); + return {ParentCtxID, ContextKind, NameID}; + } + + static data_type ReadData(internal_key_type Key, const uint8_t *Data, + unsigned Length) { + return endian::readNext<uint32_t, little, unaligned>(Data); + } +}; + +/// Used to deserialize the on-disk Objective-C property table. +class ObjCContextInfoTableInfo + : public VersionedTableInfo<ObjCContextInfoTableInfo, unsigned, + ObjCContextInfo> { +public: + static internal_key_type ReadKey(const uint8_t *Data, unsigned Length) { + return endian::readNext<uint32_t, little, unaligned>(Data); + } + + hash_value_type ComputeHash(internal_key_type Key) { + return static_cast<size_t>(llvm::hash_value(Key)); + } + + static ObjCContextInfo readUnversioned(internal_key_type Key, + const uint8_t *&Data) { + ObjCContextInfo Info; + ReadCommonTypeInfo(Data, Info); + uint8_t Payload = *Data++; + + if (Payload & 0x01) + Info.setHasDesignatedInits(true); + Payload = Payload >> 1; + + if (Payload & 0x4) + Info.setDefaultNullability(static_cast<NullabilityKind>(Payload & 0x03)); + Payload >>= 3; + + if (Payload & (1 << 1)) + Info.setSwiftObjCMembers(Payload & 1); + Payload >>= 2; + + if (Payload & (1 << 1)) + Info.setSwiftImportAsNonGeneric(Payload & 1); + + return Info; + } +}; + +/// Read serialized VariableInfo. +void ReadVariableInfo(const uint8_t *&Data, VariableInfo &Info) { + ReadCommonEntityInfo(Data, Info); + if (*Data++) { + Info.setNullabilityAudited(static_cast<NullabilityKind>(*Data)); + } + ++Data; + + auto TypeLen = endian::readNext<uint16_t, little, unaligned>(Data); + Info.setType(std::string(Data, Data + TypeLen)); + Data += TypeLen; +} + +/// Used to deserialize the on-disk Objective-C property table. +class ObjCPropertyTableInfo + : public VersionedTableInfo<ObjCPropertyTableInfo, + std::tuple<uint32_t, uint32_t, uint8_t>, + ObjCPropertyInfo> { +public: + static internal_key_type ReadKey(const uint8_t *Data, unsigned Length) { + auto ClassID = endian::readNext<uint32_t, little, unaligned>(Data); + auto NameID = endian::readNext<uint32_t, little, unaligned>(Data); + char IsInstance = endian::readNext<uint8_t, little, unaligned>(Data); + return {ClassID, NameID, IsInstance}; + } + + hash_value_type ComputeHash(internal_key_type Key) { + return static_cast<size_t>(llvm::hash_value(Key)); ---------------- egorzhdan wrote:
No good reason, replaced `djb` with `hash_value`. https://github.com/llvm/llvm-project/pull/66769 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
