mirror of
https://github.com/apple/swift.git
synced 2025-12-21 12:14:44 +01:00
7e33e554ef
* add `GlobalVariable.staticInitializerInstructions` to access all initializer instructions of a global * implement `GlobalVariable.staticInitValue` with `GlobalVariable.staticInitializerInstructions` * this requires that `InstructionList.reversed()` works without accessing the parent block of the iterator instruction * allow `Context.erase(instruction:)` to delete instructions from a global's initializer list, which means to handle the case where a deleted instruction has no parent function.
1477 lines
46 KiB
C++
1477 lines
46 KiB
C++
//===--- SILBridging.h - header for the swift SILBridging module ----------===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2021 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef SWIFT_SIL_SILBRIDGING_H
|
|
#define SWIFT_SIL_SILBRIDGING_H
|
|
|
|
#include "swift/AST/Builtins.h"
|
|
#include "swift/AST/Decl.h"
|
|
#include "swift/AST/SubstitutionMap.h"
|
|
#include "swift/Basic/BasicBridging.h"
|
|
#include "swift/Basic/BridgedSwiftObject.h"
|
|
#include "swift/Basic/Nullability.h"
|
|
#include "swift/SIL/ApplySite.h"
|
|
#include "swift/SIL/SILBuilder.h"
|
|
#include "swift/SIL/SILDefaultWitnessTable.h"
|
|
#include "swift/SIL/SILFunctionConventions.h"
|
|
#include "swift/SIL/SILInstruction.h"
|
|
#include "swift/SIL/SILLocation.h"
|
|
#include "swift/SIL/SILModule.h"
|
|
#include "swift/SIL/SILVTable.h"
|
|
#include "swift/SIL/SILWitnessTable.h"
|
|
#include <stdbool.h>
|
|
#include <stddef.h>
|
|
#include <string>
|
|
|
|
SWIFT_BEGIN_NULLABILITY_ANNOTATIONS
|
|
|
|
struct BridgedInstruction;
|
|
struct OptionalBridgedInstruction;
|
|
struct OptionalBridgedOperand;
|
|
struct OptionalBridgedSuccessor;
|
|
struct BridgedBasicBlock;
|
|
struct BridgedSuccessorArray;
|
|
struct OptionalBridgedBasicBlock;
|
|
|
|
void registerBridgedClass(llvm::StringRef className, SwiftMetatype metatype);
|
|
|
|
struct BridgedValue {
|
|
SwiftObject obj;
|
|
|
|
enum class Kind {
|
|
SingleValueInstruction,
|
|
Argument,
|
|
MultipleValueInstructionResult,
|
|
Undef
|
|
};
|
|
|
|
// Unfortunately we need to take a detour over this enum.
|
|
// Currently it's not possible to switch over `OwnershipKind::inntery`, because it's not a class enum.
|
|
enum class Ownership {
|
|
Unowned,
|
|
Owned,
|
|
Guaranteed,
|
|
None
|
|
};
|
|
|
|
Kind getKind() const;
|
|
|
|
swift::SILValue getSILValue() const { return static_cast<swift::ValueBase *>(obj); }
|
|
|
|
std::string getDebugDescription() const;
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
inline OptionalBridgedOperand getFirstUse() const;
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
swift::SILType getType() const { return getSILValue()->getType(); }
|
|
|
|
Ownership getOwnership() const {
|
|
switch (getSILValue()->getOwnershipKind()) {
|
|
case swift::OwnershipKind::Any:
|
|
llvm_unreachable("Invalid ownership for value");
|
|
case swift::OwnershipKind::Unowned: return Ownership::Unowned;
|
|
case swift::OwnershipKind::Owned: return Ownership::Owned;
|
|
case swift::OwnershipKind::Guaranteed: return Ownership::Guaranteed;
|
|
case swift::OwnershipKind::None: return Ownership::None;
|
|
}
|
|
}
|
|
};
|
|
|
|
struct OptionalBridgedValue {
|
|
OptionalSwiftObject obj;
|
|
|
|
swift::SILValue getSILValue() const {
|
|
if (obj)
|
|
return static_cast<swift::ValueBase *>(obj);
|
|
return swift::SILValue();
|
|
}
|
|
};
|
|
|
|
inline swift::ValueOwnershipKind castToOwnership(BridgedValue::Ownership ownership) {
|
|
switch (ownership) {
|
|
case BridgedValue::Ownership::Unowned: return swift::OwnershipKind::Unowned;
|
|
case BridgedValue::Ownership::Owned: return swift::OwnershipKind::Owned;
|
|
case BridgedValue::Ownership::Guaranteed: return swift::OwnershipKind::Guaranteed;
|
|
case BridgedValue::Ownership::None: return swift::OwnershipKind::None;
|
|
}
|
|
}
|
|
|
|
// This is the layout of a class existential.
|
|
struct BridgeValueExistential {
|
|
BridgedValue value;
|
|
void * _Nonnull conformance;
|
|
};
|
|
|
|
struct BridgedValueArray {
|
|
const BridgeValueExistential * _Nullable base;
|
|
size_t count;
|
|
|
|
llvm::ArrayRef<swift::SILValue> getValues(llvm::SmallVectorImpl<swift::SILValue> &storage);
|
|
};
|
|
|
|
struct BridgedOperand {
|
|
swift::Operand * _Nonnull op;
|
|
|
|
bool isTypeDependent() const { return op->isTypeDependent(); }
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
inline OptionalBridgedOperand getNextUse() const;
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedValue getValue() const { return {op->get()}; }
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
inline BridgedInstruction getUser() const;
|
|
};
|
|
|
|
struct OptionalBridgedOperand {
|
|
swift::Operand * _Nullable op;
|
|
|
|
// Assumes that `op` is not null.
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedOperand advancedBy(SwiftInt index) const { return {op + index}; }
|
|
|
|
// Assumes that `op` is not null.
|
|
SwiftInt distanceTo(BridgedOperand element) const { return element.op - op; }
|
|
};
|
|
|
|
struct BridgedOperandArray {
|
|
OptionalBridgedOperand base;
|
|
SwiftInt count;
|
|
};
|
|
|
|
// Unfortunately we need to take a detour over this enum.
|
|
// Currently it's not possible to switch over `SILArgumentConvention::ConventionType`,
|
|
// because it's not a class enum.
|
|
enum class BridgedArgumentConvention {
|
|
Indirect_In = swift::SILArgumentConvention::Indirect_In,
|
|
Indirect_In_Guaranteed = swift::SILArgumentConvention::Indirect_In_Guaranteed,
|
|
Indirect_Inout = swift::SILArgumentConvention::Indirect_Inout,
|
|
Indirect_InoutAliasable = swift::SILArgumentConvention::Indirect_InoutAliasable,
|
|
Indirect_Out = swift::SILArgumentConvention::Indirect_Out,
|
|
Direct_Owned = swift::SILArgumentConvention::Direct_Owned,
|
|
Direct_Unowned = swift::SILArgumentConvention::Direct_Unowned,
|
|
Direct_Guaranteed = swift::SILArgumentConvention::Direct_Guaranteed,
|
|
Pack_Owned = swift::SILArgumentConvention::Pack_Owned,
|
|
Pack_Inout = swift::SILArgumentConvention::Pack_Inout,
|
|
Pack_Guaranteed = swift::SILArgumentConvention::Pack_Guaranteed,
|
|
Pack_Out = swift::SILArgumentConvention::Pack_Out
|
|
};
|
|
|
|
inline BridgedArgumentConvention castToArgumentConvention(swift::SILArgumentConvention convention) {
|
|
return static_cast<BridgedArgumentConvention>(convention.Value);
|
|
}
|
|
|
|
struct BridgedFunction {
|
|
SwiftObject obj;
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
swift::SILFunction * _Nonnull getFunction() const {
|
|
return static_cast<swift::SILFunction *>(obj);
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
llvm::StringRef getName() const { return getFunction()->getName(); }
|
|
|
|
std::string getDebugDescription() const;
|
|
|
|
bool hasOwnership() const { return getFunction()->hasOwnership(); }
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
inline OptionalBridgedBasicBlock getFirstBlock() const;
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
inline OptionalBridgedBasicBlock getLastBlock() const;
|
|
|
|
SwiftInt getNumIndirectFormalResults() const {
|
|
return (SwiftInt)getFunction()->getLoweredFunctionType()->getNumIndirectFormalResults();
|
|
}
|
|
|
|
SwiftInt getNumParameters() const {
|
|
return (SwiftInt)getFunction()->getLoweredFunctionType()->getNumParameters();
|
|
}
|
|
|
|
SwiftInt getSelfArgumentIndex() const {
|
|
swift::SILFunctionConventions conv(getFunction()->getConventionsInContext());
|
|
swift::CanSILFunctionType fTy = getFunction()->getLoweredFunctionType();
|
|
if (!fTy->hasSelfParam())
|
|
return -1;
|
|
return conv.getNumParameters() + conv.getNumIndirectSILResults() - 1;
|
|
}
|
|
|
|
SwiftInt getNumSILArguments() const {
|
|
return swift::SILFunctionConventions(getFunction()->getConventionsInContext()).getNumSILArguments();
|
|
}
|
|
|
|
swift::SILType getSILArgumentType(SwiftInt idx) const {
|
|
swift::SILFunctionConventions conv(getFunction()->getConventionsInContext());
|
|
return conv.getSILArgumentType(idx, getFunction()->getTypeExpansionContext());
|
|
}
|
|
|
|
BridgedArgumentConvention getSILArgumentConvention(SwiftInt idx) const {
|
|
swift::SILFunctionConventions conv(getFunction()->getConventionsInContext());
|
|
return castToArgumentConvention(conv.getSILArgumentConvention(idx));
|
|
}
|
|
|
|
swift::SILType getSILResultType() const {
|
|
swift::SILFunctionConventions conv(getFunction()->getConventionsInContext());
|
|
return conv.getSILResultType(getFunction()->getTypeExpansionContext());
|
|
}
|
|
|
|
bool isSwift51RuntimeAvailable() const {
|
|
if (getFunction()->getResilienceExpansion() != swift::ResilienceExpansion::Maximal)
|
|
return false;
|
|
|
|
swift::ASTContext &ctxt = getFunction()->getModule().getASTContext();
|
|
return swift::AvailabilityContext::forDeploymentTarget(ctxt).isContainedIn(ctxt.getSwift51Availability());
|
|
}
|
|
|
|
bool isPossiblyUsedExternally() const {
|
|
return getFunction()->isPossiblyUsedExternally();
|
|
}
|
|
|
|
bool isAvailableExternally() const {
|
|
return getFunction()->isAvailableExternally();
|
|
}
|
|
|
|
bool isTransparent() const {
|
|
return getFunction()->isTransparent() == swift::IsTransparent;
|
|
}
|
|
|
|
bool isAsync() const {
|
|
return getFunction()->isAsync();
|
|
}
|
|
|
|
bool isGlobalInitFunction() const {
|
|
return getFunction()->isGlobalInit();
|
|
}
|
|
|
|
bool isGlobalInitOnceFunction() const {
|
|
return getFunction()->isGlobalInitOnceFunction();
|
|
}
|
|
|
|
bool hasSemanticsAttr(llvm::StringRef attrName) const {
|
|
return getFunction()->hasSemanticsAttr(attrName);
|
|
}
|
|
|
|
swift::EffectsKind getEffectAttribute() const {
|
|
return getFunction()->getEffectsKind();
|
|
}
|
|
|
|
swift::PerformanceConstraints getPerformanceConstraints() const {
|
|
return getFunction()->getPerfConstraints();
|
|
}
|
|
|
|
enum class InlineStrategy {
|
|
InlineDefault = swift::InlineDefault,
|
|
NoInline = swift::NoInline,
|
|
AlwaysInline = swift::AlwaysInline
|
|
};
|
|
|
|
InlineStrategy getInlineStrategy() const {
|
|
return (InlineStrategy)getFunction()->getInlineStrategy();
|
|
}
|
|
|
|
bool isSerialized() const {
|
|
return getFunction()->isSerialized();
|
|
}
|
|
|
|
bool hasValidLinkageForFragileRef() const {
|
|
return getFunction()->hasValidLinkageForFragileRef();
|
|
}
|
|
|
|
bool needsStackProtection() const {
|
|
return getFunction()->needsStackProtection();
|
|
}
|
|
|
|
void setNeedStackProtection(bool needSP) const {
|
|
getFunction()->setNeedStackProtection(needSP);
|
|
}
|
|
|
|
enum class ParseEffectsMode {
|
|
argumentEffectsFromSource,
|
|
argumentEffectsFromSIL,
|
|
globalEffectsFromSIL,
|
|
multipleEffectsFromSIL
|
|
};
|
|
|
|
struct ParsingError {
|
|
const unsigned char * _Nullable message;
|
|
SwiftInt position;
|
|
};
|
|
|
|
struct EffectInfo {
|
|
SwiftInt argumentIndex;
|
|
bool isDerived;
|
|
bool isEmpty;
|
|
bool isValid;
|
|
};
|
|
|
|
typedef void (* _Nonnull RegisterFn)(BridgedFunction f, void * _Nonnull data, SwiftInt size);
|
|
typedef void (* _Nonnull WriteFn)(BridgedFunction, BridgedOStream, SwiftInt);
|
|
typedef ParsingError (*_Nonnull ParseFn)(BridgedFunction,
|
|
llvm::StringRef,
|
|
ParseEffectsMode, SwiftInt,
|
|
BridgedArrayRef);
|
|
typedef SwiftInt (* _Nonnull CopyEffectsFn)(BridgedFunction, BridgedFunction);
|
|
typedef EffectInfo (* _Nonnull GetEffectInfoFn)(BridgedFunction, SwiftInt);
|
|
typedef swift::MemoryBehavior (* _Nonnull GetMemBehaviorFn)(BridgedFunction, bool);
|
|
|
|
static void registerBridging(SwiftMetatype metatype,
|
|
RegisterFn initFn, RegisterFn destroyFn,
|
|
WriteFn writeFn, ParseFn parseFn,
|
|
CopyEffectsFn copyEffectsFn,
|
|
GetEffectInfoFn effectInfoFn,
|
|
GetMemBehaviorFn memBehaviorFn);
|
|
};
|
|
|
|
struct OptionalBridgedFunction {
|
|
OptionalSwiftObject obj;
|
|
};
|
|
|
|
struct BridgedGlobalVar {
|
|
SwiftObject obj;
|
|
|
|
BridgedGlobalVar(SwiftObject obj) : obj(obj) {}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
swift::SILGlobalVariable * _Nonnull getGlobal() const {
|
|
return static_cast<swift::SILGlobalVariable *>(obj);
|
|
}
|
|
|
|
std::string getDebugDescription() const;
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
llvm::StringRef getName() const { return getGlobal()->getName(); }
|
|
|
|
bool isLet() const { return getGlobal()->isLet(); }
|
|
|
|
void setLet(bool value) const { getGlobal()->setLet(value); }
|
|
|
|
bool isPossiblyUsedExternally() const {
|
|
return getGlobal()->isPossiblyUsedExternally();
|
|
}
|
|
|
|
bool isAvailableExternally() const {
|
|
return swift::isAvailableExternally(getGlobal()->getLinkage());
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
inline OptionalBridgedInstruction getFirstStaticInitInst() const;
|
|
|
|
bool canBeInitializedStatically() const;
|
|
|
|
bool mustBeInitializedStatically() const;
|
|
};
|
|
|
|
struct OptionalBridgedGlobalVar {
|
|
OptionalSwiftObject obj;
|
|
};
|
|
|
|
struct BridgedMultiValueResult {
|
|
SwiftObject obj;
|
|
|
|
swift::MultipleValueInstructionResult * _Nonnull getMVResult() const {
|
|
return static_cast<swift::MultipleValueInstructionResult *>(obj);
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
inline BridgedInstruction getParent() const;
|
|
|
|
SwiftInt getIndex() const {
|
|
return (SwiftInt)getMVResult()->getIndex();
|
|
}
|
|
};
|
|
|
|
struct OptionalBridgedInstruction {
|
|
OptionalSwiftObject obj;
|
|
|
|
OptionalBridgedInstruction() : obj(nullptr) {}
|
|
|
|
OptionalBridgedInstruction(OptionalSwiftObject obj) : obj(obj) {}
|
|
|
|
swift::SILInstruction * _Nullable getInst() const {
|
|
if (!obj)
|
|
return nullptr;
|
|
return llvm::cast<swift::SILInstruction>(static_cast<swift::SILNode *>(obj)->castToInstruction());
|
|
}
|
|
};
|
|
|
|
struct BridgedTypeArray {
|
|
llvm::ArrayRef<swift::Type> typeArray;
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
static BridgedTypeArray fromReplacementTypes(swift::SubstitutionMap substMap) {
|
|
return {substMap.getReplacementTypes()};
|
|
}
|
|
|
|
SwiftInt getCount() const { return SwiftInt(typeArray.size()); }
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
swift::SILType getAt(SwiftInt index) const {
|
|
auto ty = typeArray[index]->getCanonicalType();
|
|
if (ty->isLegalSILType())
|
|
return swift::SILType::getPrimitiveObjectType(ty);
|
|
return swift::SILType();
|
|
}
|
|
};
|
|
|
|
struct BridgedSILTypeArray {
|
|
llvm::ArrayRef<swift::SILType> typeArray;
|
|
|
|
SwiftInt getCount() const { return SwiftInt(typeArray.size()); }
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
swift::SILType getAt(SwiftInt index) const { return typeArray[index]; }
|
|
};
|
|
|
|
struct BridgedInstruction {
|
|
SwiftObject obj;
|
|
|
|
BridgedInstruction(SwiftObject obj) : obj(obj) {}
|
|
|
|
template <class I> I *_Nonnull getAs() const {
|
|
return llvm::cast<I>(static_cast<swift::SILNode *>(obj)->castToInstruction());
|
|
}
|
|
|
|
swift::SILInstruction * _Nonnull getInst() const { return getAs<swift::SILInstruction>(); }
|
|
|
|
std::string getDebugDescription() const;
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
OptionalBridgedInstruction getNext() const {
|
|
auto iter = std::next(getInst()->getIterator());
|
|
if (iter == getInst()->getParent()->end())
|
|
return {nullptr};
|
|
return {iter->asSILNode()};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
OptionalBridgedInstruction getPrevious() const {
|
|
auto iter = std::next(getInst()->getReverseIterator());
|
|
if (iter == getInst()->getParent()->rend())
|
|
return {nullptr};
|
|
return {iter->asSILNode()};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
inline BridgedBasicBlock getParent() const;
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
inline BridgedInstruction getLastInstOfParent() const;
|
|
|
|
bool isDeleted() const {
|
|
return getInst()->isDeleted();
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedOperandArray getOperands() const {
|
|
auto operands = getInst()->getAllOperands();
|
|
return {{operands.data()}, (SwiftInt)operands.size()};
|
|
}
|
|
|
|
void setOperand(SwiftInt index, BridgedValue value) const {
|
|
getInst()->setOperand((unsigned)index, value.getSILValue());
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
swift::SILDebugLocation getLocation() const {
|
|
return getInst()->getDebugLocation();
|
|
}
|
|
|
|
swift::MemoryBehavior getMemBehavior() const {
|
|
return getInst()->getMemoryBehavior();
|
|
}
|
|
|
|
bool mayRelease() const {
|
|
return getInst()->mayRelease();
|
|
}
|
|
|
|
bool mayHaveSideEffects() const {
|
|
return getInst()->mayHaveSideEffects();
|
|
}
|
|
|
|
bool mayAccessPointer() const;
|
|
bool mayLoadWeakOrUnowned() const;
|
|
bool maySynchronizeNotConsideringSideEffects() const;
|
|
bool mayBeDeinitBarrierNotConsideringSideEffects() const;
|
|
|
|
SwiftInt MultipleValueInstruction_getNumResults() const {
|
|
return getAs<swift::MultipleValueInstruction>()->getNumResults();
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedMultiValueResult MultipleValueInstruction_getResult(SwiftInt index) const {
|
|
return {getAs<swift::MultipleValueInstruction>()->getResult(index)};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
inline BridgedSuccessorArray TermInst_getSuccessors() const;
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
llvm::StringRef CondFailInst_getMessage() const {
|
|
return getAs<swift::CondFailInst>()->getMessage();
|
|
}
|
|
|
|
SwiftInt LoadInst_getLoadOwnership() const {
|
|
return (SwiftInt)getAs<swift::LoadInst>()->getOwnershipQualifier();
|
|
}
|
|
|
|
swift::BuiltinValueKind BuiltinInst_getID() const {
|
|
return getAs<swift::BuiltinInst>()->getBuiltinInfo().ID;
|
|
}
|
|
|
|
enum class IntrinsicID {
|
|
memcpy, memmove,
|
|
unknown
|
|
};
|
|
|
|
IntrinsicID BuiltinInst_getIntrinsicID() const {
|
|
switch (getAs<swift::BuiltinInst>()->getIntrinsicInfo().ID) {
|
|
case llvm::Intrinsic::memcpy: return IntrinsicID::memcpy;
|
|
case llvm::Intrinsic::memmove: return IntrinsicID::memmove;
|
|
default: return IntrinsicID::unknown;
|
|
}
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
swift::SubstitutionMap BuiltinInst_getSubstitutionMap() const {
|
|
return getAs<swift::BuiltinInst>()->getSubstitutions();
|
|
}
|
|
|
|
bool PointerToAddressInst_isStrict() const {
|
|
return getAs<swift::PointerToAddressInst>()->isStrict();
|
|
}
|
|
|
|
bool AddressToPointerInst_needsStackProtection() const {
|
|
return getAs<swift::AddressToPointerInst>()->needsStackProtection();
|
|
}
|
|
|
|
bool IndexAddrInst_needsStackProtection() const {
|
|
return getAs<swift::IndexAddrInst>()->needsStackProtection();
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedGlobalVar GlobalAccessInst_getGlobal() const {
|
|
return {getAs<swift::GlobalAccessInst>()->getReferencedGlobal()};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedGlobalVar AllocGlobalInst_getGlobal() const {
|
|
return {getAs<swift::AllocGlobalInst>()->getReferencedGlobal()};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedFunction FunctionRefBaseInst_getReferencedFunction() const {
|
|
return {getAs<swift::FunctionRefBaseInst>()->getInitiallyReferencedFunction()};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
llvm::APInt IntegerLiteralInst_getValue() const {
|
|
return getAs<swift::IntegerLiteralInst>()->getValue();
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
llvm::APFloat FloatLiteralInst_getValue() const {
|
|
return getAs<swift::FloatLiteralInst>()->getValue();
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
llvm::StringRef StringLiteralInst_getValue() const {
|
|
return getAs<swift::StringLiteralInst>()->getValue();
|
|
}
|
|
|
|
int StringLiteralInst_getEncoding() const {
|
|
return (int)getAs<swift::StringLiteralInst>()->getEncoding();
|
|
}
|
|
|
|
SwiftInt TupleExtractInst_fieldIndex() const {
|
|
return getAs<swift::TupleExtractInst>()->getFieldIndex();
|
|
}
|
|
|
|
SwiftInt TupleElementAddrInst_fieldIndex() const {
|
|
return getAs<swift::TupleElementAddrInst>()->getFieldIndex();
|
|
}
|
|
|
|
SwiftInt StructExtractInst_fieldIndex() const {
|
|
return getAs<swift::StructExtractInst>()->getFieldIndex();
|
|
}
|
|
|
|
OptionalBridgedValue StructInst_getUniqueNonTrivialFieldValue() const {
|
|
return {getAs<swift::StructInst>()->getUniqueNonTrivialFieldValue()};
|
|
}
|
|
|
|
SwiftInt StructElementAddrInst_fieldIndex() const {
|
|
return getAs<swift::StructElementAddrInst>()->getFieldIndex();
|
|
}
|
|
|
|
SwiftInt ProjectBoxInst_fieldIndex() const {
|
|
return getAs<swift::ProjectBoxInst>()->getFieldIndex();
|
|
}
|
|
|
|
bool EndCOWMutationInst_doKeepUnique() const {
|
|
return getAs<swift::EndCOWMutationInst>()->doKeepUnique();
|
|
}
|
|
|
|
SwiftInt EnumInst_caseIndex() const {
|
|
return getAs<swift::EnumInst>()->getCaseIndex();
|
|
}
|
|
|
|
SwiftInt UncheckedEnumDataInst_caseIndex() const {
|
|
return getAs<swift::UncheckedEnumDataInst>()->getCaseIndex();
|
|
}
|
|
|
|
SwiftInt InitEnumDataAddrInst_caseIndex() const {
|
|
return getAs<swift::InitEnumDataAddrInst>()->getCaseIndex();
|
|
}
|
|
|
|
SwiftInt UncheckedTakeEnumDataAddrInst_caseIndex() const {
|
|
return getAs<swift::UncheckedTakeEnumDataAddrInst>()->getCaseIndex();
|
|
}
|
|
|
|
SwiftInt InjectEnumAddrInst_caseIndex() const {
|
|
return getAs<swift::InjectEnumAddrInst>()->getCaseIndex();
|
|
}
|
|
|
|
SwiftInt RefElementAddrInst_fieldIndex() const {
|
|
return getAs<swift::RefElementAddrInst>()->getFieldIndex();
|
|
}
|
|
|
|
bool RefElementAddrInst_fieldIsLet() const {
|
|
return getAs<swift::RefElementAddrInst>()->getField()->isLet();
|
|
}
|
|
|
|
SwiftInt PartialApplyInst_numArguments() const {
|
|
return getAs<swift::PartialApplyInst>()->getNumArguments();
|
|
}
|
|
|
|
SwiftInt ApplyInst_numArguments() const {
|
|
return getAs<swift::ApplyInst>()->getNumArguments();
|
|
}
|
|
|
|
bool ApplyInst_getNonThrowing() const {
|
|
return getAs<swift::ApplyInst>()->isNonThrowing();
|
|
}
|
|
|
|
bool ApplyInst_getNonAsync() const {
|
|
return getAs<swift::ApplyInst>()->isNonAsync();
|
|
}
|
|
|
|
const swift::GenericSpecializationInformation * _Nullable
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
ApplyInst_getSpecializationInfo() const {
|
|
return getAs<swift::ApplyInst>()->getSpecializationInfo();
|
|
}
|
|
|
|
SwiftInt ObjectInst_getNumBaseElements() const {
|
|
return getAs<swift::ObjectInst>()->getNumBaseElements();
|
|
}
|
|
|
|
SwiftInt PartialApply_getCalleeArgIndexOfFirstAppliedArg() const {
|
|
return swift::ApplySite(getInst()).getCalleeArgIndexOfFirstAppliedArg();
|
|
}
|
|
|
|
bool PartialApplyInst_isOnStack() const {
|
|
return getAs<swift::PartialApplyInst>()->isOnStack();
|
|
}
|
|
|
|
bool AllocStackInst_hasDynamicLifetime() const {
|
|
return getAs<swift::AllocStackInst>()->hasDynamicLifetime();
|
|
}
|
|
|
|
bool AllocRefInstBase_isObjc() const {
|
|
return getAs<swift::AllocRefInstBase>()->isObjC();
|
|
}
|
|
|
|
bool AllocRefInstBase_canAllocOnStack() const {
|
|
return getAs<swift::AllocRefInstBase>()->canAllocOnStack();
|
|
}
|
|
|
|
SwiftInt AllocRefInstBase_getNumTailTypes() const {
|
|
return getAs<swift::AllocRefInstBase>()->getNumTailTypes();
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedSILTypeArray AllocRefInstBase_getTailAllocatedTypes() const {
|
|
return {getAs<const swift::AllocRefInstBase>()->getTailAllocatedTypes()};
|
|
}
|
|
|
|
bool AllocRefDynamicInst_isDynamicTypeDeinitAndSizeKnownEquivalentToBaseType() const {
|
|
return getAs<swift::AllocRefDynamicInst>()->isDynamicTypeDeinitAndSizeKnownEquivalentToBaseType();
|
|
}
|
|
|
|
SwiftInt BeginApplyInst_numArguments() const {
|
|
return getAs<swift::BeginApplyInst>()->getNumArguments();
|
|
}
|
|
|
|
SwiftInt TryApplyInst_numArguments() const {
|
|
return getAs<swift::TryApplyInst>()->getNumArguments();
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
inline BridgedBasicBlock BranchInst_getTargetBlock() const;
|
|
|
|
SwiftInt SwitchEnumInst_getNumCases() const {
|
|
return getAs<swift::SwitchEnumInst>()->getNumCases();
|
|
}
|
|
|
|
SwiftInt SwitchEnumInst_getCaseIndex(SwiftInt idx) const {
|
|
auto *seInst = getAs<swift::SwitchEnumInst>();
|
|
return seInst->getModule().getCaseIndex(seInst->getCase(idx).first);
|
|
}
|
|
|
|
SwiftInt StoreInst_getStoreOwnership() const {
|
|
return (SwiftInt)getAs<swift::StoreInst>()->getOwnershipQualifier();
|
|
}
|
|
|
|
swift::SILAccessKind BeginAccessInst_getAccessKind() const {
|
|
return getAs<swift::BeginAccessInst>()->getAccessKind();
|
|
}
|
|
|
|
bool BeginAccessInst_isStatic() const {
|
|
return getAs<swift::BeginAccessInst>()->getEnforcement() == swift::SILAccessEnforcement::Static;
|
|
}
|
|
|
|
bool CopyAddrInst_isTakeOfSrc() const {
|
|
return getAs<swift::CopyAddrInst>()->isTakeOfSrc();
|
|
}
|
|
|
|
bool CopyAddrInst_isInitializationOfDest() const {
|
|
return getAs<swift::CopyAddrInst>()->isInitializationOfDest();
|
|
}
|
|
|
|
void RefCountingInst_setIsAtomic(bool isAtomic) const {
|
|
getAs<swift::RefCountingInst>()->setAtomicity(
|
|
isAtomic ? swift::RefCountingInst::Atomicity::Atomic
|
|
: swift::RefCountingInst::Atomicity::NonAtomic);
|
|
}
|
|
|
|
bool RefCountingInst_getIsAtomic() const {
|
|
return getAs<swift::RefCountingInst>()->getAtomicity() == swift::RefCountingInst::Atomicity::Atomic;
|
|
}
|
|
|
|
SwiftInt CondBranchInst_getNumTrueArgs() const {
|
|
return getAs<swift::CondBranchInst>()->getNumTrueArgs();
|
|
}
|
|
|
|
void AllocRefInstBase_setIsStackAllocatable() const {
|
|
getAs<swift::AllocRefInstBase>()->setStackAllocatable();
|
|
}
|
|
|
|
bool AllocRefInst_isBare() const {
|
|
return getAs<swift::AllocRefInst>()->isBare();
|
|
}
|
|
|
|
void AllocRefInst_setIsBare() const {
|
|
getAs<swift::AllocRefInst>()->setBare(true);
|
|
}
|
|
|
|
inline void TermInst_replaceBranchTarget(BridgedBasicBlock from, BridgedBasicBlock to) const;
|
|
|
|
SwiftInt KeyPathInst_getNumComponents() const {
|
|
if (swift::KeyPathPattern *pattern = getAs<swift::KeyPathInst>()->getPattern()) {
|
|
return (SwiftInt)pattern->getComponents().size();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
struct KeyPathFunctionResults {
|
|
enum { maxFunctions = 5 };
|
|
BridgedFunction functions[maxFunctions];
|
|
SwiftInt numFunctions;
|
|
};
|
|
|
|
void KeyPathInst_getReferencedFunctions(SwiftInt componentIdx, KeyPathFunctionResults * _Nonnull results) const {
|
|
swift::KeyPathPattern *pattern = getAs<swift::KeyPathInst>()->getPattern();
|
|
const swift::KeyPathPatternComponent &comp = pattern->getComponents()[componentIdx];
|
|
results->numFunctions = 0;
|
|
|
|
comp.visitReferencedFunctionsAndMethods([results](swift::SILFunction *func) {
|
|
assert(results->numFunctions < KeyPathFunctionResults::maxFunctions);
|
|
results->functions[results->numFunctions++] = {func};
|
|
}, [](swift::SILDeclRef) {});
|
|
}
|
|
|
|
bool GlobalValueInst_isBare() const {
|
|
return getAs<swift::GlobalValueInst>()->isBare();
|
|
}
|
|
|
|
void GlobalValueInst_setIsBare() const {
|
|
getAs<swift::GlobalValueInst>()->setBare(true);
|
|
}
|
|
|
|
void LoadInst_setOwnership(SwiftInt ownership) const {
|
|
getAs<swift::LoadInst>()->setOwnershipQualifier((swift::LoadOwnershipQualifier)ownership);
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
inline BridgedBasicBlock CheckedCastBranch_getSuccessBlock() const;
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
inline BridgedBasicBlock CheckedCastBranch_getFailureBlock() const;
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
swift::SubstitutionMap ApplySite_getSubstitutionMap() const {
|
|
auto as = swift::ApplySite(getInst());
|
|
return as.getSubstitutionMap();
|
|
}
|
|
|
|
BridgedArgumentConvention ApplySite_getArgumentConvention(SwiftInt calleeArgIdx) const {
|
|
auto as = swift::ApplySite(getInst());
|
|
auto conv = as.getSubstCalleeConv().getSILArgumentConvention(calleeArgIdx);
|
|
return castToArgumentConvention(conv.Value);
|
|
}
|
|
|
|
SwiftInt ApplySite_getNumArguments() const {
|
|
return swift::ApplySite(getInst()).getNumArguments();
|
|
}
|
|
|
|
SwiftInt FullApplySite_numIndirectResultArguments() const {
|
|
auto fas = swift::FullApplySite(getInst());
|
|
return fas.getNumIndirectSILResults();
|
|
}
|
|
};
|
|
|
|
struct BridgedArgument {
|
|
SwiftObject obj;
|
|
|
|
swift::SILArgument * _Nonnull getArgument() const {
|
|
return static_cast<swift::SILArgument *>(obj);
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
inline BridgedBasicBlock getParent() const;
|
|
|
|
BridgedArgumentConvention getConvention() const {
|
|
auto *fArg = llvm::cast<swift::SILFunctionArgument>(getArgument());
|
|
return castToArgumentConvention(fArg->getArgumentConvention());
|
|
}
|
|
};
|
|
|
|
struct OptionalBridgedArgument {
|
|
OptionalSwiftObject obj;
|
|
};
|
|
|
|
struct OptionalBridgedBasicBlock {
|
|
OptionalSwiftObject obj;
|
|
|
|
swift::SILBasicBlock * _Nullable getBlock() const {
|
|
return obj ? static_cast<swift::SILBasicBlock *>(obj) : nullptr;
|
|
}
|
|
};
|
|
|
|
struct BridgedBasicBlock {
|
|
SwiftObject obj;
|
|
|
|
BridgedBasicBlock(SwiftObject obj) : obj(obj) {}
|
|
|
|
swift::SILBasicBlock * _Nonnull getBlock() const {
|
|
return static_cast<swift::SILBasicBlock *>(obj);
|
|
}
|
|
|
|
std::string getDebugDescription() const;
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
OptionalBridgedBasicBlock getNext() const {
|
|
auto iter = std::next(getBlock()->getIterator());
|
|
if (iter == getBlock()->getParent()->end())
|
|
return {nullptr};
|
|
return {&*iter};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
OptionalBridgedBasicBlock getPrevious() const {
|
|
auto iter = std::next(getBlock()->getReverseIterator());
|
|
if (iter == getBlock()->getParent()->rend())
|
|
return {nullptr};
|
|
return {&*iter};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedFunction getFunction() const {
|
|
return {getBlock()->getParent()};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
OptionalBridgedInstruction getFirstInst() const {
|
|
if (getBlock()->empty())
|
|
return {nullptr};
|
|
return {getBlock()->front().asSILNode()};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
OptionalBridgedInstruction getLastInst() const {
|
|
if (getBlock()->empty())
|
|
return {nullptr};
|
|
return {getBlock()->back().asSILNode()};
|
|
}
|
|
|
|
SwiftInt getNumArguments() const {
|
|
return getBlock()->getNumArguments();
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedArgument getArgument(SwiftInt index) const {
|
|
return {getBlock()->getArgument(index)};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedArgument addBlockArgument(swift::SILType type, BridgedValue::Ownership ownership) const {
|
|
return {getBlock()->createPhiArgument(type, castToOwnership(ownership))};
|
|
}
|
|
|
|
void eraseArgument(SwiftInt index) const {
|
|
getBlock()->eraseArgument(index);
|
|
}
|
|
|
|
void moveAllInstructionsToBegin(BridgedBasicBlock dest) const {
|
|
dest.getBlock()->spliceAtBegin(getBlock());
|
|
}
|
|
|
|
void moveAllInstructionsToEnd(BridgedBasicBlock dest) const {
|
|
dest.getBlock()->spliceAtEnd(getBlock());
|
|
}
|
|
|
|
void moveArgumentsTo(BridgedBasicBlock dest) const {
|
|
dest.getBlock()->moveArgumentList(getBlock());
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
inline OptionalBridgedSuccessor getFirstPred() const;
|
|
};
|
|
|
|
struct BridgedSuccessor {
|
|
const swift::SILSuccessor * _Nonnull succ;
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
inline OptionalBridgedSuccessor getNext() const;
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedBasicBlock getTargetBlock() const {
|
|
return {succ->getBB()};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
inline BridgedInstruction getContainingInst() const;
|
|
};
|
|
|
|
struct OptionalBridgedSuccessor {
|
|
const swift::SILSuccessor * _Nullable succ;
|
|
|
|
// Assumes that `succ` is not null.
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedSuccessor advancedBy(SwiftInt index) const { return {succ + index}; }
|
|
};
|
|
|
|
struct BridgedSuccessorArray {
|
|
OptionalBridgedSuccessor base;
|
|
SwiftInt count;
|
|
};
|
|
|
|
struct BridgedVTableEntry {
|
|
const swift::SILVTableEntry * _Nonnull entry;
|
|
|
|
std::string getDebugDescription() const;
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedFunction getImplementation() const {
|
|
return {entry->getImplementation()};
|
|
}
|
|
};
|
|
|
|
struct BridgedVTableEntryArray {
|
|
BridgedVTableEntry base;
|
|
SwiftInt count;
|
|
};
|
|
|
|
struct BridgedVTable {
|
|
const swift::SILVTable * _Nonnull vTable;
|
|
|
|
std::string getDebugDescription() const;
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedVTableEntryArray getEntries() const {
|
|
auto entries = vTable->getEntries();
|
|
return {{entries.data()}, (SwiftInt)entries.size()};
|
|
}
|
|
};
|
|
|
|
struct BridgedWitnessTableEntry {
|
|
const swift::SILWitnessTable::Entry * _Nonnull entry;
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
std::string getDebugDescription() const;
|
|
|
|
swift::SILWitnessTable::WitnessKind getKind() const {
|
|
return entry->getKind();
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
OptionalBridgedFunction getMethodFunction() const {
|
|
return {entry->getMethodWitness().Witness};
|
|
}
|
|
};
|
|
|
|
struct BridgedWitnessTableEntryArray {
|
|
BridgedWitnessTableEntry base;
|
|
SwiftInt count;
|
|
};
|
|
|
|
struct BridgedWitnessTable {
|
|
const swift::SILWitnessTable * _Nonnull table;
|
|
|
|
std::string getDebugDescription() const;
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedWitnessTableEntryArray getEntries() const {
|
|
auto entries = table->getEntries();
|
|
return {{entries.data()}, (SwiftInt)entries.size()};
|
|
}
|
|
};
|
|
|
|
struct OptionalBridgedWitnessTable {
|
|
const swift::SILWitnessTable * _Nullable table;
|
|
};
|
|
|
|
struct BridgedDefaultWitnessTable {
|
|
const swift::SILDefaultWitnessTable * _Nonnull table;
|
|
|
|
std::string getDebugDescription() const;
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedWitnessTableEntryArray getEntries() const {
|
|
auto entries = table->getEntries();
|
|
return {{entries.data()}, (SwiftInt)entries.size()};
|
|
}
|
|
};
|
|
|
|
struct OptionalBridgedDefaultWitnessTable {
|
|
const swift::SILDefaultWitnessTable * _Nullable table;
|
|
};
|
|
|
|
struct BridgedBuilder{
|
|
|
|
enum class InsertAt {
|
|
beforeInst, endOfBlock, intoGlobal
|
|
} insertAt;
|
|
|
|
SwiftObject insertionObj;
|
|
swift::SILDebugLocation loc;
|
|
|
|
swift::SILBuilder builder() const {
|
|
switch (insertAt) {
|
|
case InsertAt::beforeInst:
|
|
return swift::SILBuilder(BridgedInstruction(insertionObj).getInst(), loc.getScope());
|
|
case InsertAt::endOfBlock:
|
|
return swift::SILBuilder(BridgedBasicBlock(insertionObj).getBlock(), loc.getScope());
|
|
case InsertAt::intoGlobal:
|
|
return swift::SILBuilder(BridgedGlobalVar(insertionObj).getGlobal());
|
|
}
|
|
}
|
|
|
|
swift::SILLocation regularLoc() const { return swift::RegularLocation(loc.getLocation()); }
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createBuiltinBinaryFunction(llvm::StringRef name,
|
|
swift::SILType operandType, swift::SILType resultType,
|
|
BridgedValueArray arguments) const {
|
|
llvm::SmallVector<swift::SILValue, 16> argValues;
|
|
return {builder().createBuiltinBinaryFunction(regularLoc(),
|
|
name, operandType, resultType,
|
|
arguments.getValues(argValues))};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createCondFail(BridgedValue condition, llvm::StringRef message) const {
|
|
return {builder().createCondFail(regularLoc(), condition.getSILValue(), message)};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createIntegerLiteral(swift::SILType type, SwiftInt value) const {
|
|
return {builder().createIntegerLiteral(regularLoc(), type, value)};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createAllocStack(swift::SILType type,
|
|
bool hasDynamicLifetime, bool isLexical, bool wasMoved) const {
|
|
return {builder().createAllocStack(regularLoc(), type, llvm::None, hasDynamicLifetime, isLexical, wasMoved)};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createDeallocStack(BridgedValue operand) const {
|
|
return {builder().createDeallocStack(regularLoc(), operand.getSILValue())};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createDeallocStackRef(BridgedValue operand) const {
|
|
return {builder().createDeallocStackRef(regularLoc(), operand.getSILValue())};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createUncheckedRefCast(BridgedValue op, swift::SILType type) const {
|
|
return {builder().createUncheckedRefCast(regularLoc(), op.getSILValue(), type)};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createUpcast(BridgedValue op, swift::SILType type) const {
|
|
return {builder().createUpcast(regularLoc(), op.getSILValue(), type)};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createLoad(BridgedValue op, SwiftInt ownership) const {
|
|
return {builder().createLoad(regularLoc(), op.getSILValue(), (swift::LoadOwnershipQualifier)ownership)};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createSetDeallocating(BridgedValue op, bool isAtomic) const {
|
|
return {builder().createSetDeallocating(regularLoc(),
|
|
op.getSILValue(),
|
|
isAtomic ? swift::RefCountingInst::Atomicity::Atomic
|
|
: swift::RefCountingInst::Atomicity::NonAtomic)};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createStrongRetain(BridgedValue op) const {
|
|
auto b = builder();
|
|
return {b.createStrongRetain(regularLoc(), op.getSILValue(), b.getDefaultAtomicity())};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createStrongRelease(BridgedValue op) const {
|
|
auto b = builder();
|
|
return {b.createStrongRelease(regularLoc(), op.getSILValue(), b.getDefaultAtomicity())};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createUnownedRetain(BridgedValue op) const {
|
|
auto b = builder();
|
|
return {b.createUnownedRetain(regularLoc(), op.getSILValue(), b.getDefaultAtomicity())};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createUnownedRelease(BridgedValue op) const {
|
|
auto b = builder();
|
|
return {b.createUnownedRelease(regularLoc(), op.getSILValue(), b.getDefaultAtomicity())};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createFunctionRef(BridgedFunction function) const {
|
|
return {builder().createFunctionRef(regularLoc(), function.getFunction())};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createCopyValue(BridgedValue op) const {
|
|
return {builder().createCopyValue(regularLoc(), op.getSILValue())};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createBeginBorrow(BridgedValue op) const {
|
|
return {builder().createBeginBorrow(regularLoc(), op.getSILValue())};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createEndBorrow(BridgedValue op) const {
|
|
return {builder().createEndBorrow(regularLoc(), op.getSILValue())};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createCopyAddr(BridgedValue from, BridgedValue to,
|
|
bool takeSource, bool initializeDest) const {
|
|
return {builder().createCopyAddr(regularLoc(),
|
|
from.getSILValue(), to.getSILValue(),
|
|
swift::IsTake_t(takeSource),
|
|
swift::IsInitialization_t(initializeDest))};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createDestroyValue(BridgedValue op) const {
|
|
return {builder().createDestroyValue(regularLoc(), op.getSILValue())};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createDestroyAddr(BridgedValue op) const {
|
|
return {builder().createDestroyAddr(regularLoc(), op.getSILValue())};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createDebugStep() const {
|
|
return {builder().createDebugStep(regularLoc())};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createApply(BridgedValue function, swift::SubstitutionMap subMap,
|
|
BridgedValueArray arguments, bool isNonThrowing, bool isNonAsync,
|
|
const swift::GenericSpecializationInformation * _Nullable specInfo) const {
|
|
llvm::SmallVector<swift::SILValue, 16> argValues;
|
|
swift::ApplyOptions applyOpts;
|
|
if (isNonThrowing) { applyOpts |= swift::ApplyFlags::DoesNotThrow; }
|
|
if (isNonAsync) { applyOpts |= swift::ApplyFlags::DoesNotAwait; }
|
|
|
|
return {builder().createApply(regularLoc(),
|
|
function.getSILValue(), subMap,
|
|
arguments.getValues(argValues),
|
|
applyOpts, specInfo)};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createSwitchEnumInst(BridgedValue enumVal, OptionalBridgedBasicBlock defaultBlock,
|
|
const void * _Nullable enumCases, SwiftInt numEnumCases) const {
|
|
using BridgedCase = const std::pair<SwiftInt, BridgedBasicBlock>;
|
|
llvm::ArrayRef<BridgedCase> cases(static_cast<BridgedCase *>(enumCases),
|
|
(unsigned)numEnumCases);
|
|
llvm::SmallDenseMap<SwiftInt, swift::EnumElementDecl *> mappedElements;
|
|
swift::SILValue en = enumVal.getSILValue();
|
|
swift::EnumDecl *enumDecl = en->getType().getEnumOrBoundGenericEnum();
|
|
for (auto elemWithIndex : llvm::enumerate(enumDecl->getAllElements())) {
|
|
mappedElements[elemWithIndex.index()] = elemWithIndex.value();
|
|
}
|
|
llvm::SmallVector<std::pair<swift::EnumElementDecl *, swift::SILBasicBlock *>, 16> convertedCases;
|
|
for (auto c : cases) {
|
|
assert(mappedElements.count(c.first) && "wrong enum element index");
|
|
convertedCases.push_back({mappedElements[c.first], c.second.getBlock()});
|
|
}
|
|
return {builder().createSwitchEnum(regularLoc(),
|
|
enumVal.getSILValue(),
|
|
defaultBlock.getBlock(), convertedCases)};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createUncheckedEnumData(BridgedValue enumVal, SwiftInt caseIdx,
|
|
swift::SILType resultType) const {
|
|
swift::SILValue en = enumVal.getSILValue();
|
|
return {builder().createUncheckedEnumData(regularLoc(), enumVal.getSILValue(),
|
|
en->getType().getEnumElement(caseIdx), resultType)};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createEnum(SwiftInt caseIdx, OptionalBridgedValue payload,
|
|
swift::SILType resultType) const {
|
|
swift::EnumElementDecl *caseDecl = resultType.getEnumElement(caseIdx);
|
|
swift::SILValue pl = payload.getSILValue();
|
|
return {builder().createEnum(regularLoc(), pl, caseDecl, resultType)};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createBranch(BridgedBasicBlock destBlock, BridgedValueArray arguments) const {
|
|
llvm::SmallVector<swift::SILValue, 16> argValues;
|
|
return {builder().createBranch(regularLoc(), destBlock.getBlock(), arguments.getValues(argValues))};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createUnreachable() const {
|
|
return {builder().createUnreachable(regularLoc())};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createObject(swift::SILType type, BridgedValueArray arguments, SwiftInt numBaseElements) const {
|
|
llvm::SmallVector<swift::SILValue, 16> argValues;
|
|
return {builder().createObject(swift::ArtificialUnreachableLocation(),
|
|
type, arguments.getValues(argValues), numBaseElements)};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createGlobalAddr(BridgedGlobalVar global) const {
|
|
return {builder().createGlobalAddr(regularLoc(), global.getGlobal())};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createGlobalValue(BridgedGlobalVar global, bool isBare) const {
|
|
return {builder().createGlobalValue(regularLoc(), global.getGlobal(), isBare)};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createStruct(swift::SILType type, BridgedValueArray elements) const {
|
|
llvm::SmallVector<swift::SILValue, 16> elementValues;
|
|
return {builder().createStruct(regularLoc(), type, elements.getValues(elementValues))};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createStructExtract(BridgedValue str, SwiftInt fieldIndex) const {
|
|
swift::SILValue v = str.getSILValue();
|
|
return {builder().createStructExtract(regularLoc(), v, v->getType().getFieldDecl(fieldIndex))};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createStructElementAddr(BridgedValue addr, SwiftInt fieldIndex) const {
|
|
swift::SILValue v = addr.getSILValue();
|
|
return {builder().createStructElementAddr(regularLoc(), v, v->getType().getFieldDecl(fieldIndex))};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createDestructureStruct(BridgedValue str) const {
|
|
return {builder().createDestructureStruct(regularLoc(), str.getSILValue())};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createTuple(swift::SILType type, BridgedValueArray elements) const {
|
|
llvm::SmallVector<swift::SILValue, 16> elementValues;
|
|
return {builder().createTuple(regularLoc(), type, elements.getValues(elementValues))};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createTupleExtract(BridgedValue str, SwiftInt elementIndex) const {
|
|
swift::SILValue v = str.getSILValue();
|
|
return {builder().createTupleExtract(regularLoc(), v, elementIndex)};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createTupleElementAddr(BridgedValue addr, SwiftInt elementIndex) const {
|
|
swift::SILValue v = addr.getSILValue();
|
|
return {builder().createTupleElementAddr(regularLoc(), v, elementIndex)};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createDestructureTuple(BridgedValue str) const {
|
|
return {builder().createDestructureTuple(regularLoc(), str.getSILValue())};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createStore(BridgedValue src, BridgedValue dst,
|
|
SwiftInt ownership) const {
|
|
return {builder().createStore(regularLoc(), src.getSILValue(), dst.getSILValue(),
|
|
(swift::StoreOwnershipQualifier)ownership)};
|
|
}
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
BridgedInstruction createInitExistentialRef(BridgedValue instance,
|
|
swift::SILType type,
|
|
BridgedInstruction useConformancesOf) const {
|
|
auto *src = useConformancesOf.getAs<swift::InitExistentialRefInst>();
|
|
return {builder().createInitExistentialRef(regularLoc(), type,
|
|
src->getFormalConcreteType(),
|
|
instance.getSILValue(),
|
|
src->getConformances())};
|
|
}
|
|
};
|
|
|
|
// AST bridging
|
|
|
|
struct BridgedNominalTypeDecl {
|
|
swift::NominalTypeDecl * _Nonnull decl;
|
|
|
|
SWIFT_IMPORT_UNSAFE
|
|
llvm::StringRef getName() const {
|
|
return decl->getName().str();
|
|
}
|
|
|
|
bool isStructWithUnreferenceableStorage() const;
|
|
};
|
|
|
|
// Passmanager and Context
|
|
|
|
namespace swift {
|
|
class SwiftPassInvocation;
|
|
}
|
|
|
|
struct BridgedChangeNotificationHandler {
|
|
swift::SwiftPassInvocation * _Nonnull invocation;
|
|
|
|
enum class Kind {
|
|
instructionsChanged,
|
|
callsChanged,
|
|
branchesChanged,
|
|
effectsChanged
|
|
};
|
|
|
|
void notifyChanges(Kind changeKind) const;
|
|
};
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Inline functions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
OptionalBridgedOperand BridgedOperand::getNextUse() const {
|
|
return {op->getNextUse()};
|
|
}
|
|
|
|
BridgedInstruction BridgedOperand::getUser() const {
|
|
return {op->getUser()->asSILNode()};
|
|
}
|
|
|
|
OptionalBridgedOperand BridgedValue::getFirstUse() const {
|
|
return {*getSILValue()->use_begin()};
|
|
}
|
|
|
|
OptionalBridgedSuccessor BridgedSuccessor::getNext() const {
|
|
return {succ->getNext()};
|
|
}
|
|
|
|
BridgedInstruction BridgedSuccessor::getContainingInst() const {
|
|
return {succ->getContainingInst()};
|
|
}
|
|
|
|
OptionalBridgedBasicBlock BridgedFunction::getFirstBlock() const {
|
|
return {getFunction()->empty() ? nullptr : getFunction()->getEntryBlock()};
|
|
}
|
|
|
|
OptionalBridgedBasicBlock BridgedFunction::getLastBlock() const {
|
|
return {getFunction()->empty() ? nullptr : &*getFunction()->rbegin()};
|
|
}
|
|
|
|
OptionalBridgedInstruction BridgedGlobalVar::getFirstStaticInitInst() const {
|
|
if (getGlobal()->begin() == getGlobal()->end()) {
|
|
return {nullptr};
|
|
}
|
|
swift::SILInstruction *firstInst = &*getGlobal()->begin();
|
|
return {firstInst->asSILNode()};
|
|
}
|
|
|
|
BridgedInstruction BridgedMultiValueResult::getParent() const {
|
|
return {getMVResult()->getParent()};
|
|
}
|
|
|
|
BridgedBasicBlock BridgedInstruction::getParent() const {
|
|
assert(!getInst()->isStaticInitializerInst() &&
|
|
"cannot get the parent of a static initializer instruction");
|
|
return {getInst()->getParent()};
|
|
}
|
|
|
|
inline BridgedInstruction BridgedInstruction::getLastInstOfParent() const {
|
|
return {getInst()->getParent()->back().asSILNode()};
|
|
}
|
|
|
|
BridgedSuccessorArray BridgedInstruction::TermInst_getSuccessors() const {
|
|
auto successors = getAs<swift::TermInst>()->getSuccessors();
|
|
return {{successors.data()}, (SwiftInt)successors.size()};
|
|
}
|
|
|
|
BridgedBasicBlock BridgedInstruction::BranchInst_getTargetBlock() const {
|
|
return {getAs<swift::BranchInst>()->getDestBB()};
|
|
}
|
|
|
|
void BridgedInstruction::TermInst_replaceBranchTarget(BridgedBasicBlock from, BridgedBasicBlock to) const {
|
|
getAs<swift::TermInst>()->replaceBranchTarget(from.getBlock(), to.getBlock());
|
|
}
|
|
|
|
BridgedBasicBlock BridgedInstruction::CheckedCastBranch_getSuccessBlock() const {
|
|
return {getAs<swift::CheckedCastBranchInst>()->getSuccessBB()};
|
|
}
|
|
|
|
inline BridgedBasicBlock BridgedInstruction::CheckedCastBranch_getFailureBlock() const {
|
|
return {getAs<swift::CheckedCastBranchInst>()->getFailureBB()};
|
|
}
|
|
|
|
OptionalBridgedSuccessor BridgedBasicBlock::getFirstPred() const {
|
|
return {getBlock()->pred_begin().getSuccessorRef()};
|
|
}
|
|
|
|
BridgedBasicBlock BridgedArgument::getParent() const {
|
|
return {getArgument()->getParent()};
|
|
}
|
|
|
|
|
|
SWIFT_END_NULLABILITY_ANNOTATIONS
|
|
|
|
#endif
|