//===-- APINotesWriter.h - API Notes Writer ---------------------*- 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

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_CLANG_LIB_APINOTES_APINOTESFORMAT_H

#define LLVM_CLANG_LIB_APINOTES_APINOTESFORMAT_H

#include "clang/APINotes/Types.h"

#include "llvm/ADT/PointerEmbeddedInt.h"

#include "llvm/Bitcode/BitcodeConvenience.h"

namespace clang {

namespace api_notes {

/// Magic number for API notes files.

const unsigned char API_NOTES_SIGNATURE[] = {0xE2, 0x9C, 0xA8, 0x01};

/// API notes file major version number.

const uint16_t VERSION_MAJOR = 0;

/// API notes file minor version number.

///

/// When the format changes IN ANY WAY, this number should be incremented.

const uint16_t VERSION_MINOR = 25; // SwiftImportAs

using IdentifierID = llvm::PointerEmbeddedInt<unsigned, 31>;

using IdentifierIDField = llvm::BCVBR<16>;

using SelectorID = llvm::PointerEmbeddedInt<unsigned, 31>;

using SelectorIDField = llvm::BCVBR<16>;

/// The various types of blocks that can occur within a API notes file.

///

/// These IDs must \em not be renumbered or reordered without incrementing

/// VERSION_MAJOR.

enum BlockID {

  /// The control block, which contains all of the information that needs to

  /// be validated prior to committing to loading the API notes file.

  ///

  /// \sa control_block

  CONTROL_BLOCK_ID = llvm::bitc::FIRST_APPLICATION_BLOCKID,

  /// The identifier data block, which maps identifier strings to IDs.

  IDENTIFIER_BLOCK_ID,

  /// The Objective-C context data block, which contains information about

  /// Objective-C classes and protocols.

  OBJC_CONTEXT_BLOCK_ID,

  /// The Objective-C property data block, which maps Objective-C

  /// (class name, property name) pairs to information about the

  /// property.

  OBJC_PROPERTY_BLOCK_ID,

  /// The Objective-C property data block, which maps Objective-C

  /// (class name, selector, is_instance_method) tuples to information

  /// about the method.

  OBJC_METHOD_BLOCK_ID,

  /// The Objective-C selector data block, which maps Objective-C

  /// selector names (# of pieces, identifier IDs) to the selector ID

  /// used in other tables.

  OBJC_SELECTOR_BLOCK_ID,

  /// The global variables data block, which maps global variable names to

  /// information about the global variable.

  GLOBAL_VARIABLE_BLOCK_ID,

  /// The (global) functions data block, which maps global function names to

  /// information about the global function.

  GLOBAL_FUNCTION_BLOCK_ID,

  /// The tag data block, which maps tag names to information about

  /// the tags.

  TAG_BLOCK_ID,

  /// The typedef data block, which maps typedef names to information about

  /// the typedefs.

  TYPEDEF_BLOCK_ID,

  /// The enum constant data block, which maps enumerator names to

  /// information about the enumerators.

  ENUM_CONSTANT_BLOCK_ID,

};

namespace control_block {

// These IDs must \em not be renumbered or reordered without incrementing

// VERSION_MAJOR.

enum {

  METADATA = 1,

  MODULE_NAME = 2,

  MODULE_OPTIONS = 3,

  SOURCE_FILE = 4,

};

using MetadataLayout =

    llvm::BCRecordLayout<METADATA,          // ID

                         llvm::BCFixed<16>, // Module format major version

                         llvm::BCFixed<16>  // Module format minor version

                         >;

using ModuleNameLayout = llvm::BCRecordLayout<MODULE_NAME,

                                              llvm::BCBlob // Module name

                                              >;

using ModuleOptionsLayout =

    llvm::BCRecordLayout<MODULE_OPTIONS,

                         llvm::BCFixed<1> // SwiftInferImportAsMember

                         >;

using SourceFileLayout = llvm::BCRecordLayout<SOURCE_FILE,

                                              llvm::BCVBR<16>, // file size

                                              llvm::BCVBR<16>  // creation time

                                              >;

} // namespace control_block

namespace identifier_block {

enum {

  IDENTIFIER_DATA = 1,

};

using IdentifierDataLayout = llvm::BCRecordLayout<

    IDENTIFIER_DATA, // record ID

    llvm::BCVBR<16>, // table offset within the blob (see below)

    llvm::BCBlob     // map from identifier strings to decl kinds / decl IDs

    >;

} // namespace identifier_block

namespace objc_context_block {

enum {

  OBJC_CONTEXT_ID_DATA = 1,

  OBJC_CONTEXT_INFO_DATA = 2,

};

using ObjCContextIDLayout =

    llvm::BCRecordLayout<OBJC_CONTEXT_ID_DATA, // record ID

                         llvm::BCVBR<16>, // table offset within the blob (see

                                          // below)

                         llvm::BCBlob // map from ObjC class names/protocol (as

                                      // IDs) to context IDs

                         >;

using ObjCContextInfoLayout = llvm::BCRecordLayout<

    OBJC_CONTEXT_INFO_DATA, // record ID

    llvm::BCVBR<16>,        // table offset within the blob (see below)

    llvm::BCBlob            // map from ObjC context IDs to context information.

    >;

} // namespace objc_context_block

namespace objc_property_block {

enum {

  OBJC_PROPERTY_DATA = 1,

};

using ObjCPropertyDataLayout = llvm::BCRecordLayout<

    OBJC_PROPERTY_DATA, // record ID

    llvm::BCVBR<16>,    // table offset within the blob (see below)

    llvm::BCBlob        // map from ObjC (class name, property name) pairs to

                        // ObjC property information

    >;

} // namespace objc_property_block

namespace objc_method_block {

enum {

  OBJC_METHOD_DATA = 1,

};

using ObjCMethodDataLayout =

    llvm::BCRecordLayout<OBJC_METHOD_DATA, // record ID

                         llvm::BCVBR<16>,  // table offset within the blob (see

                                           // below)

                         llvm::BCBlob // map from ObjC (class names, selector,

                                      // is-instance-method) tuples to ObjC

                                      // method information

                         >;

} // namespace objc_method_block

namespace objc_selector_block {

enum {

  OBJC_SELECTOR_DATA = 1,

};

using ObjCSelectorDataLayout =

    llvm::BCRecordLayout<OBJC_SELECTOR_DATA, // record ID

                         llvm::BCVBR<16>, // table offset within the blob (see

                                          // below)

                         llvm::BCBlob // map from (# pieces, identifier IDs) to

                                      // Objective-C selector ID.

                         >;

} // namespace objc_selector_block

namespace global_variable_block {

enum { GLOBAL_VARIABLE_DATA = 1 };

using GlobalVariableDataLayout = llvm::BCRecordLayout<

    GLOBAL_VARIABLE_DATA, // record ID

    llvm::BCVBR<16>,      // table offset within the blob (see below)

    llvm::BCBlob          // map from name to global variable information

    >;

} // namespace global_variable_block

namespace global_function_block {

enum { GLOBAL_FUNCTION_DATA = 1 };

using GlobalFunctionDataLayout = llvm::BCRecordLayout<

    GLOBAL_FUNCTION_DATA, // record ID

    llvm::BCVBR<16>,      // table offset within the blob (see below)

    llvm::BCBlob          // map from name to global function information

    >;

} // namespace global_function_block

namespace tag_block {

enum { TAG_DATA = 1 };

using TagDataLayout =

    llvm::BCRecordLayout<TAG_DATA,        // record ID

                         llvm::BCVBR<16>, // table offset within the blob (see

                                          // below)

                         llvm::BCBlob     // map from name to tag information

                         >;

} // namespace tag_block

namespace typedef_block {

enum { TYPEDEF_DATA = 1 };

using TypedefDataLayout =

    llvm::BCRecordLayout<TYPEDEF_DATA,    // record ID

                         llvm::BCVBR<16>, // table offset within the blob (see

                                          // below)

                         llvm::BCBlob // map from name to typedef information

                         >;

} // namespace typedef_block

namespace enum_constant_block {

enum { ENUM_CONSTANT_DATA = 1 };

using EnumConstantDataLayout =

    llvm::BCRecordLayout<ENUM_CONSTANT_DATA, // record ID

                         llvm::BCVBR<16>, // table offset within the blob (see

                                          // below)

                         llvm::BCBlob // map from name to enumerator information

                         >;

} // namespace enum_constant_block

/// A stored Objective-C selector.

struct StoredObjCSelector {

  unsigned NumArgs;

  llvm::SmallVector<IdentifierID, 2> Identifiers;

};

/// A stored Objective-C or C++ context, represented by the ID of its parent

/// context, the kind of this context (Objective-C class / C++ namespace / etc),

/// and the ID of this context.

struct ContextTableKey {

  uint32_t parentContextID;

  uint8_t contextKind;

  uint32_t contextID;

  ContextTableKey() : parentContextID(-1), contextKind(-1), contextID(-1) {}

  ContextTableKey(uint32_t parentContextID, uint8_t contextKind,

                  uint32_t contextID)

      : parentContextID(parentContextID), contextKind(contextKind),

        contextID(contextID) {}

  ContextTableKey(std::optional<Context> context, IdentifierID nameID)

      : parentContextID(context ? context->id.Value : (uint32_t)-1),

        contextKind(context ? static_cast<uint8_t>(context->kind)

                            : static_cast<uint8_t>(-1)),

        contextID(nameID) {}

  llvm::hash_code hashValue() const {

    return llvm::hash_value(

        std::tuple{parentContextID, contextKind, contextID});

  }

};

inline bool operator==(const ContextTableKey &lhs, const ContextTableKey &rhs) {

  return lhs.parentContextID == rhs.parentContextID &&

         lhs.contextKind == rhs.contextKind && lhs.contextID == rhs.contextID;

}

} // namespace api_notes

} // namespace clang

namespace llvm {

template <> struct DenseMapInfo<clang::api_notes::StoredObjCSelector> {

  typedef DenseMapInfo<unsigned> UnsignedInfo;

  static inline clang::api_notes::StoredObjCSelector getEmptyKey() {

    return clang::api_notes::StoredObjCSelector{UnsignedInfo::getEmptyKey(),

                                                {}};

  }

  static inline clang::api_notes::StoredObjCSelector getTombstoneKey() {

    return clang::api_notes::StoredObjCSelector{UnsignedInfo::getTombstoneKey(),

                                                {}};

  }

  static unsigned

  getHashValue(const clang::api_notes::StoredObjCSelector &Selector) {

    auto hash = llvm::hash_value(Selector.NumArgs);

    hash = hash_combine(hash, Selector.Identifiers.size());

    for (auto piece : Selector.Identifiers)

      hash = hash_combine(hash, static_cast<unsigned>(piece));

    // FIXME: Mix upper/lower 32-bit values together to produce

    // unsigned rather than truncating.

    return hash;

  }

  static bool isEqual(const clang::api_notes::StoredObjCSelector &LHS,

                      const clang::api_notes::StoredObjCSelector &RHS) {

    return LHS.NumArgs == RHS.NumArgs && LHS.Identifiers == RHS.Identifiers;

  }

};

template <> struct DenseMapInfo<clang::api_notes::ContextTableKey> {

  static inline clang::api_notes::ContextTableKey getEmptyKey() {

    return clang::api_notes::ContextTableKey();

  }

  static inline clang::api_notes::ContextTableKey getTombstoneKey() {

    return clang::api_notes::ContextTableKey{

        DenseMapInfo<uint32_t>::getTombstoneKey(),

        DenseMapInfo<uint8_t>::getTombstoneKey(),

        DenseMapInfo<uint32_t>::getTombstoneKey()};

  }

  static unsigned getHashValue(const clang::api_notes::ContextTableKey &value) {

    return value.hashValue();

  }

  static bool isEqual(const clang::api_notes::ContextTableKey &lhs,

                      const clang::api_notes::ContextTableKey &rhs) {

    return lhs == rhs;

  }

};

} // namespace llvm

#endif