mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
2db6f3d213
As there are no instructions left which produce multiple result values, this is a NFC regarding the generated SIL and generated code. Although this commit is large, most changes are straightforward adoptions to the changes in the ValueBase and SILValue classes.
119 lines
3.8 KiB
C++
119 lines
3.8 KiB
C++
//===--- SIL.cpp - Implements random SIL functionality --------------------===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
|
|
// Licensed under Apache License v2.0 with Runtime Library Exception
|
|
//
|
|
// See http://swift.org/LICENSE.txt for license information
|
|
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "swift/SIL/FormalLinkage.h"
|
|
#include "swift/SIL/SILModule.h"
|
|
#include "swift/SIL/SILBuilder.h"
|
|
#include "swift/SIL/SILDeclRef.h"
|
|
#include "swift/SIL/SILType.h"
|
|
#include "swift/SIL/SILUndef.h"
|
|
#include "swift/AST/ASTContext.h"
|
|
#include "swift/AST/AnyFunctionRef.h"
|
|
#include "swift/AST/Decl.h"
|
|
#include "swift/AST/Expr.h"
|
|
#include "swift/AST/Mangle.h"
|
|
#include "swift/AST/Pattern.h"
|
|
#include "swift/ClangImporter/ClangModule.h"
|
|
#include "swift/Basic/Fallthrough.h"
|
|
#include "clang/AST/Attr.h"
|
|
#include "clang/AST/Decl.h"
|
|
#include "clang/AST/DeclObjC.h"
|
|
using namespace swift;
|
|
|
|
void ValueBase::replaceAllUsesWith(ValueBase *RHS) {
|
|
assert(this != RHS && "Cannot RAUW a value with itself");
|
|
while (!use_empty()) {
|
|
Operand *Op = *use_begin();
|
|
Op->set(RHS);
|
|
}
|
|
}
|
|
|
|
|
|
SILUndef *SILUndef::get(SILType Ty, SILModule *M) {
|
|
// Unique these.
|
|
SILUndef *&Entry = M->UndefValues[Ty];
|
|
if (Entry == nullptr)
|
|
Entry = new (*M) SILUndef(Ty);
|
|
return Entry;
|
|
}
|
|
|
|
FormalLinkage swift::getDeclLinkage(const ValueDecl *D) {
|
|
const DeclContext *fileContext = D->getDeclContext()->getModuleScopeContext();
|
|
|
|
// Clang declarations are public and can't be assured of having a
|
|
// unique defining location.
|
|
if (isa<ClangModuleUnit>(fileContext))
|
|
return FormalLinkage::PublicNonUnique;
|
|
|
|
if (!D->hasAccessibility()) {
|
|
assert(D->getDeclContext()->isLocalContext());
|
|
return FormalLinkage::Private;
|
|
}
|
|
|
|
switch (D->getEffectiveAccess()) {
|
|
case Accessibility::Public:
|
|
return FormalLinkage::PublicUnique;
|
|
case Accessibility::Internal:
|
|
// FIXME: This ought to be "hidden" as well, but that causes problems when
|
|
// inlining code from the standard library, which may reference internal
|
|
// declarations.
|
|
return FormalLinkage::PublicUnique;
|
|
case Accessibility::Private:
|
|
// Why "hidden" instead of "private"? Because the debugger may need to
|
|
// access these symbols.
|
|
return FormalLinkage::HiddenUnique;
|
|
}
|
|
}
|
|
|
|
FormalLinkage swift::getTypeLinkage(CanType type) {
|
|
FormalLinkage result = FormalLinkage::Top;
|
|
|
|
// Merge all nominal types from the structural type.
|
|
(void) type.findIf([&](Type _type) {
|
|
CanType type = CanType(_type);
|
|
|
|
// For any nominal type reference, look at the type declaration.
|
|
if (auto nominal = type->getAnyNominal())
|
|
result ^= getDeclLinkage(nominal);
|
|
|
|
assert(!isa<PolymorphicFunctionType>(type) &&
|
|
"Don't expect a polymorphic function type here");
|
|
|
|
return false; // continue searching
|
|
});
|
|
|
|
return result;
|
|
}
|
|
|
|
SILLinkage swift::getSILLinkage(FormalLinkage linkage,
|
|
ForDefinition_t forDefinition) {
|
|
switch (linkage) {
|
|
case FormalLinkage::PublicUnique:
|
|
return (forDefinition ? SILLinkage::Public : SILLinkage::PublicExternal);
|
|
|
|
case FormalLinkage::PublicNonUnique:
|
|
// FIXME: any place we have to do this that actually requires
|
|
// uniqueness is buggy.
|
|
return (forDefinition ? SILLinkage::Shared : SILLinkage::PublicExternal);
|
|
|
|
case FormalLinkage::HiddenUnique:
|
|
return (forDefinition ? SILLinkage::Hidden : SILLinkage::HiddenExternal);
|
|
|
|
case FormalLinkage::HiddenNonUnique:
|
|
return (forDefinition ? SILLinkage::Shared : SILLinkage::HiddenExternal);
|
|
|
|
case FormalLinkage::Private:
|
|
return SILLinkage::Private;
|
|
}
|
|
llvm_unreachable("bad formal linkage");
|
|
}
|