//===--- SwiftRemoteMirrorLegacyInterop.h - Interop with legacy libs. -*- C++ -*-===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------------===//
///
/// \file
/// This header provides an interface for using multiple versions of the Swift remote
/// mirror library to inspect processes built with different versions of Swift, or
/// processes where different libraries are built with different versions of Swift.
///
//===----------------------------------------------------------------------------===//

#ifndef SWIFT_REMOTE_MIRROR_LEGACY_INTEROP_H
#define SWIFT_REMOTE_MIRROR_LEGACY_INTEROP_H

#if defined(__APPLE__) && defined(__MACH__)

#include "SwiftRemoteMirrorLegacyInteropTypes.h"
#include "SwiftRemoteMirror.h"

#include <dlfcn.h>
#include <mach-o/getsect.h>

/// The "public" interface follows. All of these functions are the same
/// as the corresponding swift_reflection_* functions, except for taking
/// or returning _interop data types in some circumstances.

static inline SwiftReflectionInteropContextRef
swift_reflection_interop_createReflectionContext(
    void *ReaderContext,
    void *LibraryHandle,
    void *LegacyLibraryHandle,
    uint8_t PointerSize,
    FreeBytesFunction FreeBytes,
    ReadBytesFunction ReadBytes,
    GetStringLengthFunction GetStringLength,
    GetSymbolAddressFunction GetSymbolAddress);

static inline void
swift_reflection_interop_destroyReflectionContext(
  SwiftReflectionInteropContextRef ContextRef);

static inline int
swift_reflection_interop_addImage(SwiftReflectionInteropContextRef ContextRef,
                                  swift_addr_t imageStart);

static inline int
swift_reflection_interop_readIsaMask(SwiftReflectionInteropContextRef ContextRef,
                                     uintptr_t *outIsaMask);

static inline swift_typeref_interop_t
swift_reflection_interop_typeRefForMetadata(SwiftReflectionInteropContextRef ContextRef,
                                            swift_metadata_interop_t Metadata);

static inline swift_typeref_interop_t
swift_reflection_interop_typeRefForInstance(SwiftReflectionInteropContextRef ContextRef,
                                            uintptr_t Object);

static inline swift_typeref_interop_t
swift_reflection_interop_typeRefForMangledTypeName(
  SwiftReflectionInteropContextRef ContextRef,
  const char *MangledName,
  uint64_t Length);

static inline swift_typeinfo_t
swift_reflection_interop_infoForTypeRef(SwiftReflectionInteropContextRef ContextRef,
                                        swift_typeref_interop_t OpaqueTypeRef);

static inline swift_childinfo_t
swift_reflection_interop_childOfTypeRef(SwiftReflectionInteropContextRef ContextRef,
                                       swift_typeref_interop_t OpaqueTypeRef,
                                        unsigned Index);

static inline swift_typeinfo_t
swift_reflection_interop_infoForMetadata(SwiftReflectionInteropContextRef ContextRef,
                                        swift_metadata_interop_t Metadata);

static inline swift_childinfo_t
swift_reflection_interop_childOfMetadata(SwiftReflectionInteropContextRef ContextRef,
                                        swift_metadata_interop_t Metadata,
                                        unsigned Index);

static inline swift_typeinfo_t
swift_reflection_interop_infoForInstance(SwiftReflectionInteropContextRef ContextRef,
                                         uintptr_t Object);

static inline swift_childinfo_t
swift_reflection_interop_childOfInstance(SwiftReflectionInteropContextRef ContextRef,
                                         uintptr_t Object,
                                         unsigned Index);

static inline unsigned
swift_reflection_interop_genericArgumentCountOfTypeRef(
  SwiftReflectionInteropContextRef ContextRef, swift_typeref_interop_t OpaqueTypeRef);

static inline swift_typeref_interop_t
swift_reflection_interop_genericArgumentOfTypeRef(
  SwiftReflectionInteropContextRef ContextRef, swift_typeref_interop_t OpaqueTypeRef,
  unsigned Index);

static inline int
swift_reflection_interop_projectExistential(SwiftReflectionInteropContextRef ContextRef,
                                            swift_addr_t ExistentialAddress,
                                            swift_typeref_interop_t ExistentialTypeRef,
                                            swift_typeref_interop_t *OutInstanceTypeRef,
                                            swift_addr_t *OutStartOfInstanceData);

static inline void
swift_reflection_interop_dumpTypeRef(SwiftReflectionInteropContextRef ContextRef,
                                     swift_typeref_interop_t OpaqueTypeRef);

static inline void
swift_reflection_interop_dumpInfoForTypeRef(SwiftReflectionInteropContextRef ContextRef,
                                            swift_typeref_interop_t OpaqueTypeRef);

static inline void
swift_reflection_interop_dumpInfoForMetadata(SwiftReflectionInteropContextRef ContextRef,
                                             swift_metadata_interop_t Metadata);

static inline void
swift_reflection_interop_dumpInfoForInstance(SwiftReflectionInteropContextRef ContextRef,
                                             uintptr_t Object);

static inline size_t
swift_reflection_interop_demangle(SwiftReflectionInteropContextRef ContextRef,
                                  const char *MangledName,
                                  size_t Length,
                                  char *OutDemangledName,
                                  size_t MaxLength);


/// \name Internal implementation details, clients don't need to use these.
/// @{

/// The minimum supported metadata version for the legacy library.
#define SWIFT_LEGACY_METADATA_MIN_VERSION 3

/// The legacy reflection info struct.
typedef struct swift_reflection_legacy_info {
  swift_reflection_section_t fieldmd;
  swift_reflection_section_t assocty;
  swift_reflection_section_t builtin;
  swift_reflection_section_t capture;
  swift_reflection_section_t typeref;
  swift_reflection_section_t reflstr;
  uintptr_t LocalStartAddress;
  uintptr_t RemoteStartAddress;
} swift_reflection_legacy_info_t;

/// The signature of the legacy ReadBytesFunction.
typedef int (*ReadBytesFunctionLegacy)(void *reader_context, swift_addr_t address,
                                       void *dest, uint64_t size);

struct SwiftReflectionFunctions {
  uint16_t (*getSupportedMetadataVersion)(void);

  SwiftReflectionContextRef (*createReflectionContext)(
    void *ReaderContext,
    uint8_t PointerSize,
    FreeBytesFunction FreeBytes,
    ReadBytesFunction ReadBytes,
    GetStringLengthFunction GetStringLength,
    GetSymbolAddressFunction GetSymbolAddress);
  
  SwiftReflectionContextRef (*createReflectionContextLegacy)(
    void *ReaderContext,
    PointerSizeFunction getPointerSize,
    SizeSizeFunction getSizeSize,
    ReadBytesFunctionLegacy readBytes,
    GetStringLengthFunction getStringLength,
    GetSymbolAddressFunction getSymbolAddress);
  
  void (*destroyReflectionContext)(SwiftReflectionContextRef Context);
  
  void (*addReflectionInfo)(SwiftReflectionContextRef Context,
                            swift_reflection_info_t Info);

  void (*addReflectionInfoLegacy)(SwiftReflectionContextRef Context,
                                  swift_reflection_legacy_info_t Info);

  int (*addImage)(SwiftReflectionContextRef ContextRef,
                  swift_addr_t imageStart);

  int (*readIsaMask)(SwiftReflectionContextRef ContextRef, uintptr_t *outIsaMask);
  
  swift_typeref_t (*typeRefForMetadata)(SwiftReflectionContextRef ContextRef,
                                        uintptr_t Metadata);
  
  int (*ownsObject)(SwiftReflectionContextRef ContextRef, uintptr_t Object);
  
  uintptr_t (*metadataForObject)(SwiftReflectionContextRef ContextRef, uintptr_t Object);
  
  swift_typeref_t (*typeRefForInstance)(SwiftReflectionContextRef ContextRef,
                                        uintptr_t Object);

  swift_typeref_t (*typeRefForMangledTypeName)(SwiftReflectionContextRef ContextRef,
                                           const char *MangledName,
                                           uint64_t Length);

  swift_typeinfo_t (*infoForTypeRef)(SwiftReflectionContextRef ContextRef,
                                      swift_typeref_t OpaqueTypeRef);

  swift_childinfo_t (*childOfTypeRef)(SwiftReflectionContextRef ContextRef,
                                      swift_typeref_t OpaqueTypeRef,
                                      unsigned Index);

  swift_typeinfo_t (*infoForMetadata)(SwiftReflectionContextRef ContextRef,
                                      uintptr_t Metadata);

  swift_childinfo_t (*childOfMetadata)(SwiftReflectionContextRef ContextRef,
                                       uintptr_t Metadata,
                                       unsigned Index);
  swift_typeinfo_t (*infoForInstance)(SwiftReflectionContextRef ContextRef,
                                      uintptr_t Object);

  swift_childinfo_t (*childOfInstance)(SwiftReflectionContextRef ContextRef,
                                       uintptr_t Object,
                                       unsigned Index);

  unsigned (*genericArgumentCountOfTypeRef)(swift_typeref_t OpaqueTypeRef);

  swift_typeref_t (*genericArgumentOfTypeRef)(swift_typeref_t OpaqueTypeRef,
                                              unsigned Index);

  int (*projectExistential)(SwiftReflectionContextRef ContextRef,
                            swift_addr_t ExistentialAddress,
                            swift_typeref_t ExistentialTypeRef,
                            swift_typeref_t *OutInstanceTypeRef,
                            swift_addr_t *OutStartOfInstanceData);

  void (*dumpTypeRef)(swift_typeref_t OpaqueTypeRef);

  void (*dumpInfoForTypeRef)(SwiftReflectionContextRef ContextRef,
                             swift_typeref_t OpaqueTypeRef);

  void (*dumpInfoForMetadata)(SwiftReflectionContextRef ContextRef,
                              uintptr_t Metadata);

  void (*dumpInfoForInstance)(SwiftReflectionContextRef ContextRef,
                              uintptr_t Object);

  size_t (*demangle)(const char *MangledName,
                     size_t Length,
                     char *OutDemangledName,
                     size_t MaxLength);
};

struct SwiftReflectionInteropContextLibrary {
  SwiftReflectionContextRef Context;
  struct SwiftReflectionFunctions Functions;
  int IsLegacy;
};

struct SwiftReflectionInteropContextFreeList {
  struct SwiftReflectionInteropContextFreeList *Next;
  const void *Pointer;
  void *Context;
};

struct SwiftReflectionInteropContextLegacyDataSegmentList {
  struct SwiftReflectionInteropContextLegacyDataSegmentList *Next;
  swift_addr_t Start, End;
};

struct SwiftReflectionInteropContext {
  void *ReaderContext;
  FreeBytesFunction FreeBytes;
  ReadBytesFunction ReadBytes;
  uint64_t (*GetStringLength)(void *reader_context,
                              swift_addr_t address);
  swift_addr_t (*GetSymbolAddress)(void *reader_context,
                                   const char *name,
                                   uint64_t name_length);
  
  // Currently we support at most two libraries.
  struct SwiftReflectionInteropContextLibrary Libraries[2];
  int LibraryCount;
  
  struct SwiftReflectionInteropContextFreeList *FreeList;
  struct SwiftReflectionInteropContextLegacyDataSegmentList *LegacyDataSegmentList;
};

#define FOREACH_LIBRARY \
  for (struct SwiftReflectionInteropContextLibrary *Library = &ContextRef->Libraries[0]; \
       Library < &ContextRef->Libraries[ContextRef->LibraryCount]; \
       ++Library)
#define LIBRARY_INDEX (Library - ContextRef->Libraries)
#define DECLARE_LIBRARY(index) \
  struct SwiftReflectionInteropContextLibrary *Library = &ContextRef->Libraries[index]

static inline int
swift_reflection_interop_libraryOwnsObject(
  struct SwiftReflectionInteropContext *ContextRef,
  struct SwiftReflectionInteropContextLibrary *Library,
  uintptr_t Object) {
  if (!Library->IsLegacy)
    return Library->Functions.ownsObject(Library->Context, Object);
  
  // The legacy library doesn't have this. Do it ourselves if we can. We need
  // metadataForObject from a non-legacy library to do it.
  uintptr_t Metadata = 0;
  FOREACH_LIBRARY {
    if (Library->IsLegacy)
      continue;
    
    Metadata = Library->Functions.metadataForObject(Library->Context, Object);
    break;
  }
  
  // If we couldn't retrieve metadata, assume it's ours.
  if (Metadata == 0)
    return 1;
  
  // Search the data segment list to see if the metadata is in one of them.
  struct SwiftReflectionInteropContextLegacyDataSegmentList *Node =
    ContextRef->LegacyDataSegmentList;
  while (Node != NULL) {
    if (Node->Start <= Metadata && Metadata < Node->End)
      return 1;
    Node = Node->Next;
  }
  return 0;
}

static inline void
swift_reflection_interop_loadFunctions(struct SwiftReflectionInteropContext *Context,
                                       void *Handle,
                                       int IsLegacy) {
  if (Handle == NULL)
    return;

  struct SwiftReflectionInteropContextLibrary *Library = &Context
    ->Libraries[Context->LibraryCount];
  struct SwiftReflectionFunctions *Functions = &Library->Functions;

#ifndef __cplusplus
#define decltype(x) void *
#endif
#define LOAD_NAMED(field, symbol) do { \
    Functions->field = (decltype(Functions->field))dlsym(Handle, symbol); \
    if (Functions->field == NULL) return; \
  } while (0)
#define LOAD(name) LOAD_NAMED(name, "swift_reflection_" #name)
  
  LOAD(getSupportedMetadataVersion);
  uint16_t version = Functions->getSupportedMetadataVersion();
  if (version < SWIFT_LEGACY_METADATA_MIN_VERSION)
    return;
  
  if (IsLegacy) {
    LOAD_NAMED(createReflectionContextLegacy, "swift_reflection_createReflectionContext");
    LOAD_NAMED(addReflectionInfoLegacy, "swift_reflection_addReflectionInfo");
  } else {
    LOAD(createReflectionContext);
    LOAD(addReflectionInfo);
    LOAD(addImage);
    LOAD(ownsObject);
    LOAD(metadataForObject);
  }
  
  LOAD(destroyReflectionContext);
  LOAD(readIsaMask);
  LOAD(typeRefForMetadata);
  LOAD(typeRefForInstance);
  LOAD(typeRefForMangledTypeName);
  LOAD(infoForTypeRef);
  LOAD(childOfTypeRef);
  LOAD(infoForMetadata);
  LOAD(childOfMetadata);
  LOAD(infoForInstance);
  LOAD(childOfInstance);
  LOAD(genericArgumentCountOfTypeRef);
  LOAD(genericArgumentOfTypeRef);
  LOAD(projectExistential);
  LOAD(dumpTypeRef);
  LOAD(dumpInfoForTypeRef);
  
  Library->IsLegacy = IsLegacy;
  Context->LibraryCount++;
  
  return;
  
#undef LOAD
#undef LOAD_NAMED
#ifndef __cplusplus
#undef decltype
#endif
}

static inline int
swift_reflection_interop_readBytesAdapter(void *reader_context,
                                          swift_addr_t address,
                                          void *dest,
                                          uint64_t size) {
  SwiftReflectionInteropContextRef Context =
    (SwiftReflectionInteropContextRef)reader_context;

  void *FreeContext;
  const void *ptr = Context->ReadBytes(Context->ReaderContext, address, size,
                                       &FreeContext);
  if (ptr == NULL)
    return 0;
  
  memcpy(dest, ptr, size);
  if (Context->FreeBytes != NULL)
    Context->FreeBytes(Context->ReaderContext, ptr, FreeContext);
  return 1;
}

static inline uint8_t
swift_reflection_interop_getSizeAdapter(void *reader_context) {
  // Legacy library doesn't pay attention to these anyway.
  return sizeof(void *);
}

static inline uint64_t
swift_reflection_interop_GetStringLengthAdapter(
  void *reader_context, swift_addr_t address) {
  SwiftReflectionInteropContextRef Context =
    (SwiftReflectionInteropContextRef)reader_context;
  return Context->GetStringLength(Context->ReaderContext, address);
}

static inline swift_addr_t
swift_reflection_interop_GetSymbolAddressAdapter(
  void *reader_context, const char *name, uint64_t name_length) {
  SwiftReflectionInteropContextRef Context =
    (SwiftReflectionInteropContextRef)reader_context;
  return Context->GetSymbolAddress(Context->ReaderContext, name, name_length);
}

static inline SwiftReflectionInteropContextRef
swift_reflection_interop_createReflectionContext(
    void *ReaderContext,
    void *LibraryHandle,
    void *LegacyLibraryHandle,
    uint8_t PointerSize,
    FreeBytesFunction FreeBytes,
    ReadBytesFunction ReadBytes,
    GetStringLengthFunction GetStringLength,
    GetSymbolAddressFunction GetSymbolAddress) {
  
  SwiftReflectionInteropContextRef ContextRef =
    (SwiftReflectionInteropContextRef)calloc(sizeof(*ContextRef), 1);
  
  swift_reflection_interop_loadFunctions(ContextRef, LibraryHandle, 0);
  swift_reflection_interop_loadFunctions(ContextRef, LegacyLibraryHandle, 1);
  
  if (ContextRef->LibraryCount == 0) {
    free(ContextRef);
    return NULL;
  }
  
  FOREACH_LIBRARY {
    if (Library->IsLegacy) {
      Library->Context = Library->Functions.createReflectionContextLegacy(
        ContextRef,
        swift_reflection_interop_getSizeAdapter, swift_reflection_interop_getSizeAdapter,
        swift_reflection_interop_readBytesAdapter,
        swift_reflection_interop_GetStringLengthAdapter,
        swift_reflection_interop_GetSymbolAddressAdapter);
    } else {
      Library->Context = Library->Functions.createReflectionContext(ReaderContext,
      PointerSize, FreeBytes, ReadBytes, GetStringLength, GetSymbolAddress);
    }
  }
  
  ContextRef->ReaderContext = ReaderContext;
  ContextRef->FreeBytes = FreeBytes;
  ContextRef->ReadBytes = ReadBytes;
  ContextRef->GetStringLength = GetStringLength;
  ContextRef->GetSymbolAddress = GetSymbolAddress;
  
  return ContextRef;
}

static inline void
swift_reflection_interop_destroyReflectionContext(
  SwiftReflectionInteropContextRef ContextRef) {
  FOREACH_LIBRARY {
    Library->Functions.destroyReflectionContext(Library->Context);
  }
  struct SwiftReflectionInteropContextLegacyDataSegmentList *LegacyDataSegmentList
    = ContextRef->LegacyDataSegmentList;
  while (LegacyDataSegmentList != NULL) {
    struct SwiftReflectionInteropContextLegacyDataSegmentList *Next
      = LegacyDataSegmentList->Next;
    free(LegacyDataSegmentList);
    LegacyDataSegmentList = Next;
  }
  struct SwiftReflectionInteropContextFreeList *FreeList = ContextRef->FreeList;
  while (FreeList != NULL) {
    ContextRef->FreeBytes(ContextRef->ReaderContext,
                          FreeList->Pointer, FreeList->Context);
    struct SwiftReflectionInteropContextFreeList *Next = FreeList->Next;
    free(FreeList);
    FreeList = Next;
  }
  free(ContextRef);
}

#ifndef __LP64__
typedef const struct mach_header MachHeader;
#else
typedef const struct mach_header_64 MachHeader;
#endif

static inline int
swift_reflection_interop_findSection(MachHeader *Header, const char *Name,
                                     swift_reflection_section_t *Sect) {
  unsigned long Size;
  void *Address = getsectiondata(Header, "__TEXT", Name, &Size);
  if (!Address)
    return 0;
  
  Sect->Begin = Address;
  Sect->End = (void *)((uintptr_t)Address + Size);
  return 1;
}

static inline int
swift_reflection_interop_addImageLegacy(
  SwiftReflectionInteropContextRef ContextRef,
  struct SwiftReflectionInteropContextLibrary *Library,
  swift_addr_t ImageStart) {
  void *FreeContext;
  const void *Buf;
  Buf = ContextRef->ReadBytes(ContextRef->ReaderContext,
                              ImageStart,
                              sizeof(MachHeader),
                              &FreeContext);
  if (Buf == NULL)
    return 0;
  
  MachHeader *Header = (MachHeader *)Buf;
  
  if (Header->magic != MH_MAGIC && Header->magic != MH_MAGIC_64) {
    if (ContextRef->FreeBytes != NULL)
      ContextRef->FreeBytes(ContextRef->ReaderContext, Buf, FreeContext);
    return 0;
  }
  
  // Read the commands.
  uint32_t Length = Header->sizeofcmds;
  if (ContextRef->FreeBytes != NULL)
    ContextRef->FreeBytes(ContextRef->ReaderContext, Buf, FreeContext);
  
  Buf = ContextRef->ReadBytes(ContextRef->ReaderContext,
                              ImageStart,
                              Length,
                              &FreeContext);
  if (Buf == NULL)
    return 0;
  Header = (MachHeader *)Buf;
  
  // Find the TEXT segment and figure out where the end is.
  unsigned long TextSize;
  uint8_t *TextSegment = getsegmentdata(Header, "__TEXT", &TextSize);
  if (ContextRef->FreeBytes != NULL)
    ContextRef->FreeBytes(ContextRef->ReaderContext, Buf, FreeContext);
  
  if (TextSegment == NULL) {
    return 0;
  }
  unsigned long TextEnd = TextSegment - (uint8_t *)Buf + TextSize;

  // Read everything including the TEXT segment.
  Buf = ContextRef->ReadBytes(ContextRef->ReaderContext,
                              ImageStart,
                              TextEnd,
                              &FreeContext);
  if (Buf == NULL)
    return 0;
  Header = (MachHeader *)Buf;

  // Find all the sections and fill out the reflection info.
  swift_reflection_legacy_info_t info = {};
  
  int success = 0;
  success = swift_reflection_interop_findSection(Header,
                                                 "__swift3_fieldmd",
                                                 &info.fieldmd) || success;
  success = swift_reflection_interop_findSection(Header,
                                                 "__swift3_assocty",
                                                 &info.assocty) || success;
  success = swift_reflection_interop_findSection(Header,
                                                 "__swift3_builtin",
                                                 &info.builtin) || success;
  success = swift_reflection_interop_findSection(Header,
                                                 "__swift3_capture",
                                                 &info.capture) || success;
  success = swift_reflection_interop_findSection(Header,
                                                 "__swift3_typeref",
                                                 &info.typeref) || success;
  success = swift_reflection_interop_findSection(Header,
                                                 "__swift3_reflstr",
                                                 &info.reflstr) || success;
  
  if (!success) {
    if (ContextRef->FreeBytes != NULL)
      ContextRef->FreeBytes(ContextRef->ReaderContext, Buf, FreeContext);
    return 0;
  }
    
  info.LocalStartAddress = (uintptr_t)Buf;
  info.RemoteStartAddress = ImageStart;
  
  Library->Functions.addReflectionInfoLegacy(Library->Context, info);
  
  // Find the data segment and add it to our list.
  unsigned long DataSize;
  const uint8_t *DataSegment = getsegmentdata(Header, "__DATA", &DataSize);
  
  struct SwiftReflectionInteropContextLegacyDataSegmentList *Node =
    (struct SwiftReflectionInteropContextLegacyDataSegmentList *)malloc(sizeof(*Node));
  Node->Next = ContextRef->LegacyDataSegmentList;
  Node->Start = DataSegment - (const uint8_t *)Buf + ImageStart;
  Node->End = Node->Start + DataSize;
  ContextRef->LegacyDataSegmentList = Node;
  
  // If the buffer needs to be freed, save buffer and free context to free it when the
  //  reflection context is destroyed.
  if (ContextRef->FreeBytes != NULL) {
    struct SwiftReflectionInteropContextFreeList *Node =
      (struct SwiftReflectionInteropContextFreeList *)malloc(sizeof(*Node));
    Node->Next = ContextRef->FreeList;
    Node->Pointer = Buf;
    Node->Context = FreeContext;
    ContextRef->FreeList = Node;
  }
  
  return 1;
}

static inline int
swift_reflection_interop_addImage(SwiftReflectionInteropContextRef ContextRef,
                                  swift_addr_t imageStart) {
  FOREACH_LIBRARY {
    int Success;
    if (Library->IsLegacy) {
      Success = swift_reflection_interop_addImageLegacy(ContextRef,
                                                        Library,
                                                        imageStart);
    } else {
      Success = Library->Functions.addImage(Library->Context, imageStart);
    }
    if (Success) {
      return 1;
    }
  }
  return 0;
}

static inline int
swift_reflection_interop_readIsaMask(SwiftReflectionInteropContextRef ContextRef,
                                     uintptr_t *outIsaMask) {
  FOREACH_LIBRARY {
    int Success = Library->Functions.readIsaMask(Library->Context, outIsaMask);
    if (Success)
      return 1;
  }
  return 0;
}

static inline swift_typeref_interop_t
swift_reflection_interop_typeRefForMetadata(SwiftReflectionInteropContextRef ContextRef,
                                            swift_metadata_interop_t Metadata) {
  DECLARE_LIBRARY(Metadata.Library);
  swift_typeref_interop_t Result;
  Result.Typeref = Library->Functions.
    typeRefForMetadata(Library->Context, Metadata.Metadata);
  Result.Library = Metadata.Library;
  return Result;
}

static inline swift_typeref_interop_t
swift_reflection_interop_typeRefForInstance(SwiftReflectionInteropContextRef ContextRef,
                                            uintptr_t Object) {
  swift_typeref_interop_t Result;
  FOREACH_LIBRARY {
    if (!swift_reflection_interop_libraryOwnsObject(ContextRef, Library, Object))
      continue;
    swift_typeref_t Typeref = Library->Functions.typeRefForInstance(Library->Context,
                                                                     Object);
    if (Typeref == 0)
      continue;
    
    Result.Typeref = Typeref;
    Result.Library = LIBRARY_INDEX;
    return Result;
  }
  
  Result.Typeref = 0;
  Result.Library = 0;
  return Result;
}

static inline swift_typeref_interop_t
swift_reflection_interop_typeRefForMangledTypeName(
  SwiftReflectionInteropContextRef ContextRef,
  const char *MangledName,
  uint64_t Length) {
  swift_typeref_interop_t Result;
  FOREACH_LIBRARY {
    swift_typeref_t Typeref = Library->Functions.typeRefForMangledTypeName(
      Library->Context, MangledName, Length);
    if (Typeref == 0)
      continue;
    
    Result.Typeref = Typeref;
    Result.Library = LIBRARY_INDEX;
    return Result;
  }
  
  Result.Typeref = 0;
  Result.Library = 0;
  return Result;
}

static inline swift_typeinfo_t
swift_reflection_interop_infoForTypeRef(SwiftReflectionInteropContextRef ContextRef,
                                        swift_typeref_interop_t OpaqueTypeRef) {
  DECLARE_LIBRARY(OpaqueTypeRef.Library);
  return Library->Functions.infoForTypeRef(Library->Context, OpaqueTypeRef.Typeref);
}

static inline swift_childinfo_t
swift_reflection_interop_childOfTypeRef(SwiftReflectionInteropContextRef ContextRef,
                                       swift_typeref_interop_t OpaqueTypeRef,
                                        unsigned Index) {
  DECLARE_LIBRARY(OpaqueTypeRef.Library);
  return Library->Functions.childOfTypeRef(Library->Context,
                                           OpaqueTypeRef.Typeref,
                                           Index);
}

static inline swift_typeinfo_t
swift_reflection_interop_infoForMetadata(SwiftReflectionInteropContextRef ContextRef,
                                        swift_metadata_interop_t Metadata) {
  DECLARE_LIBRARY(Metadata.Library);
  return Library->Functions.infoForMetadata(Library->Context, Metadata.Metadata);
}

static inline swift_childinfo_t
swift_reflection_interop_childOfMetadata(SwiftReflectionInteropContextRef ContextRef,
                                        swift_metadata_interop_t Metadata,
                                        unsigned Index) {
  DECLARE_LIBRARY(Metadata.Library);
  return Library->Functions.childOfMetadata(Library->Context, Metadata.Metadata, Index);
}

static inline swift_typeinfo_t
swift_reflection_interop_infoForInstance(SwiftReflectionInteropContextRef ContextRef,
                                         uintptr_t Object) {
  swift_typeinfo_t Result = {};
  FOREACH_LIBRARY {
    if (!swift_reflection_interop_libraryOwnsObject(ContextRef, Library, Object))
      continue;
    
    Result = Library->Functions.infoForInstance(Library->Context, Object);
    if (Result.Kind == SWIFT_UNKNOWN)
      continue;
    
    return Result;
  }
  
  Result.Kind = SWIFT_UNKNOWN;
  return Result;
}

static inline swift_childinfo_t
swift_reflection_interop_childOfInstance(SwiftReflectionInteropContextRef ContextRef,
                                         uintptr_t Object,
                                         unsigned Index) {
  FOREACH_LIBRARY {
    if (!swift_reflection_interop_libraryOwnsObject(ContextRef, Library, Object))
      continue;
    
    return Library->Functions.childOfInstance(Library->Context, Object, Index);
  }
  
  swift_childinfo_t Result = {};
  Result.Kind = SWIFT_UNKNOWN;
  return Result;
}

static inline unsigned
swift_reflection_interop_genericArgumentCountOfTypeRef(
  SwiftReflectionInteropContextRef ContextRef, swift_typeref_interop_t OpaqueTypeRef) {
  DECLARE_LIBRARY(OpaqueTypeRef.Library);
  return Library->Functions.genericArgumentCountOfTypeRef(OpaqueTypeRef.Typeref);
}

static inline swift_typeref_interop_t
swift_reflection_interop_genericArgumentOfTypeRef(
  SwiftReflectionInteropContextRef ContextRef, swift_typeref_interop_t OpaqueTypeRef,
  unsigned Index) {
  DECLARE_LIBRARY(OpaqueTypeRef.Library);
  swift_typeref_interop_t Result;
  Result.Typeref = Library->Functions.genericArgumentOfTypeRef(OpaqueTypeRef.Typeref,
                                                               Index);
  Result.Library = OpaqueTypeRef.Library;
  return Result;
}

static inline int
swift_reflection_interop_projectExistential(SwiftReflectionInteropContextRef ContextRef,
                                            swift_addr_t ExistentialAddress,
                                            swift_typeref_interop_t ExistentialTypeRef,
                                            swift_typeref_interop_t *OutInstanceTypeRef,
                                            swift_addr_t *OutStartOfInstanceData) {
  DECLARE_LIBRARY(ExistentialTypeRef.Library);
  int Success = Library->Functions.projectExistential(Library->Context,
                                                      ExistentialAddress,
                                                      ExistentialTypeRef.Typeref,
                                                      &OutInstanceTypeRef->Typeref,
                                                      OutStartOfInstanceData);
  if (!Success)
    return 0;
  
  OutInstanceTypeRef->Library = ExistentialTypeRef.Library;
  return 1;
}

static inline void
swift_reflection_interop_dumpTypeRef(SwiftReflectionInteropContextRef ContextRef,
                                     swift_typeref_interop_t OpaqueTypeRef) {
  DECLARE_LIBRARY(OpaqueTypeRef.Library);
  Library->Functions.dumpTypeRef(OpaqueTypeRef.Typeref);
}

static inline void
swift_reflection_interop_dumpInfoForTypeRef(
  SwiftReflectionInteropContextRef ContextRef, swift_typeref_interop_t OpaqueTypeRef) {
  DECLARE_LIBRARY(OpaqueTypeRef.Library);
  Library->Functions.dumpInfoForTypeRef(Library->Context, OpaqueTypeRef.Typeref);
}

static inline void
swift_reflection_interop_dumpInfoForMetadata(SwiftReflectionInteropContextRef ContextRef,
                                                  swift_metadata_interop_t Metadata) {
  DECLARE_LIBRARY(Metadata.Library);
  Library->Functions.dumpInfoForMetadata(Library->Context, Metadata.Metadata);
}

static inline void
swift_reflection_interop_dumpInfoForInstance(SwiftReflectionInteropContextRef ContextRef,
                                                  uintptr_t Object) {
  FOREACH_LIBRARY {
    if (!swift_reflection_interop_libraryOwnsObject(ContextRef, Library, Object))
      continue;
    
    Library->Functions.dumpInfoForInstance(Library->Context, Object);
    return;
  }
}

static inline size_t
swift_reflection_interop_demangle(SwiftReflectionInteropContextRef ContextRef,
                                  const char *MangledName,
                                  size_t Length,
                                  char *OutDemangledName,
                                  size_t MaxLength) {
  FOREACH_LIBRARY {
    return Library->Functions.demangle(MangledName, Length, OutDemangledName, MaxLength);
  }
  return 0;
}

#undef FOREACH_LIBRARY
#undef LIBRARY_INDEX
#undef DECLARE_LIBRARY

/// @}

#endif // defined(__APPLE__) && defined(__MACH__)

#endif // SWIFT_REMOTE_MIRROR_LEGACY_INTEROP_H