mirror of
https://github.com/apple/swift.git
synced 2025-12-21 12:14:44 +01:00
07d4558c1c
This commit changes the Swift mangler from a utility that writes tokens into a stream into a name-builder that has two phases: "building a name", and "ready". This clear separation is needed for the implementation of the compression layer. Users of the mangler can continue to build the name using the mangleXXX methods, but to access the results the users of the mangler need to call the finalize() method. This method can write the result into a stream, like before, or return an std::string.
295 lines
12 KiB
C++
295 lines
12 KiB
C++
//===--- Linking.cpp - Name mangling for IRGen entities -------------------===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2015 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements name mangling for IRGen entities with linkage.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "Linking.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
#include "swift/Basic/Fallthrough.h"
|
|
#include "swift/ClangImporter/ClangImporter.h"
|
|
#include "swift/SIL/SILGlobalVariable.h"
|
|
#include "swift/AST/Mangle.h"
|
|
#include "clang/AST/Attr.h"
|
|
#include "clang/AST/Decl.h"
|
|
#include "clang/AST/DeclObjC.h"
|
|
|
|
using namespace swift;
|
|
using namespace irgen;
|
|
using namespace Mangle;
|
|
|
|
static StringRef mangleValueWitness(ValueWitness witness) {
|
|
// The ones with at least one capital are the composite ops, and the
|
|
// capitals correspond roughly to the positions of buffers (as
|
|
// opposed to objects) in the arguments. That doesn't serve any
|
|
// direct purpose, but it's neat.
|
|
switch (witness) {
|
|
case ValueWitness::AllocateBuffer: return "al";
|
|
case ValueWitness::AssignWithCopy: return "ca";
|
|
case ValueWitness::AssignWithTake: return "ta";
|
|
case ValueWitness::DeallocateBuffer: return "de";
|
|
case ValueWitness::Destroy: return "xx";
|
|
case ValueWitness::DestroyBuffer: return "XX";
|
|
case ValueWitness::DestroyArray: return "Xx";
|
|
case ValueWitness::InitializeBufferWithCopyOfBuffer: return "CP";
|
|
case ValueWitness::InitializeBufferWithCopy: return "Cp";
|
|
case ValueWitness::InitializeWithCopy: return "cp";
|
|
case ValueWitness::InitializeBufferWithTake: return "Tk";
|
|
case ValueWitness::InitializeWithTake: return "tk";
|
|
case ValueWitness::ProjectBuffer: return "pr";
|
|
case ValueWitness::InitializeBufferWithTakeOfBuffer: return "TK";
|
|
case ValueWitness::InitializeArrayWithCopy: return "Cc";
|
|
case ValueWitness::InitializeArrayWithTakeFrontToBack: return "Tt";
|
|
case ValueWitness::InitializeArrayWithTakeBackToFront: return "tT";
|
|
case ValueWitness::StoreExtraInhabitant: return "xs";
|
|
case ValueWitness::GetExtraInhabitantIndex: return "xg";
|
|
case ValueWitness::GetEnumTag: return "ug";
|
|
case ValueWitness::DestructiveProjectEnumData: return "up";
|
|
case ValueWitness::DestructiveInjectEnumTag: return "ui";
|
|
|
|
case ValueWitness::Size:
|
|
case ValueWitness::Flags:
|
|
case ValueWitness::Stride:
|
|
case ValueWitness::ExtraInhabitantFlags:
|
|
llvm_unreachable("not a function witness");
|
|
}
|
|
llvm_unreachable("bad witness kind");
|
|
}
|
|
|
|
/// Mangle this entity into the given buffer.
|
|
void LinkEntity::mangle(SmallVectorImpl<char> &buffer) const {
|
|
llvm::raw_svector_ostream stream(buffer);
|
|
mangle(stream);
|
|
}
|
|
|
|
/// Use the Clang importer to mangle a Clang declaration.
|
|
static void mangleClangDecl(raw_ostream &buffer,
|
|
const clang::NamedDecl *clangDecl,
|
|
ASTContext &ctx) {
|
|
auto *importer = static_cast<ClangImporter *>(ctx.getClangModuleLoader());
|
|
importer->getMangledName(buffer, clangDecl);
|
|
}
|
|
|
|
/// Mangle this entity into the given stream.
|
|
void LinkEntity::mangle(raw_ostream &buffer) const {
|
|
// Almost everything below gets the common prefix:
|
|
// mangled-name ::= '_T' global
|
|
Mangler mangler;
|
|
switch (getKind()) {
|
|
// global ::= 'w' value-witness-kind type // value witness
|
|
case Kind::ValueWitness:
|
|
mangler.append("_Tw");
|
|
mangler.append(mangleValueWitness(getValueWitness()));
|
|
mangler.mangleType(getType(), ResilienceExpansion::Minimal, 0);
|
|
return mangler.finalize(buffer);
|
|
|
|
// global ::= 'WV' type // value witness
|
|
case Kind::ValueWitnessTable:
|
|
mangler.append("_TWV");
|
|
mangler.mangleType(getType(), ResilienceExpansion::Minimal, 0);
|
|
return mangler.finalize(buffer);
|
|
|
|
// global ::= 't' type
|
|
// Abstract type manglings just follow <type>.
|
|
case Kind::TypeMangling:
|
|
mangler.mangleType(getType(), ResilienceExpansion::Minimal, 0);
|
|
return mangler.finalize(buffer);
|
|
|
|
// global ::= 'Ma' type // type metadata access function
|
|
case Kind::TypeMetadataAccessFunction:
|
|
mangler.append("_TMa");
|
|
mangler.mangleType(getType(), ResilienceExpansion::Minimal, 0);
|
|
return mangler.finalize(buffer);
|
|
|
|
// global ::= 'ML' type // type metadata lazy cache variable
|
|
case Kind::TypeMetadataLazyCacheVariable:
|
|
mangler.append("_TML");
|
|
mangler.mangleType(getType(), ResilienceExpansion::Minimal, 0);
|
|
return mangler.finalize(buffer);
|
|
|
|
// global ::= 'Mf' type // 'full' type metadata
|
|
// global ::= 'M' directness type // type metadata
|
|
// global ::= 'MP' directness type // type metadata pattern
|
|
case Kind::TypeMetadata:
|
|
switch (getMetadataAddress()) {
|
|
case TypeMetadataAddress::FullMetadata:
|
|
mangler.mangleTypeFullMetadataFull(getType());
|
|
break;
|
|
case TypeMetadataAddress::AddressPoint:
|
|
mangler.mangleTypeMetadataFull(getType(), isMetadataPattern());
|
|
break;
|
|
}
|
|
return mangler.finalize(buffer);
|
|
|
|
// global ::= 'M' directness type // type metadata
|
|
case Kind::ForeignTypeMetadataCandidate:
|
|
mangler.mangleTypeMetadataFull(getType(), /*isPattern=*/false);
|
|
return mangler.finalize(buffer);
|
|
|
|
// global ::= 'Mm' type // class metaclass
|
|
case Kind::SwiftMetaclassStub:
|
|
mangler.append("_TMm");
|
|
mangler.mangleNominalType(cast<ClassDecl>(getDecl()),
|
|
ResilienceExpansion::Minimal,
|
|
Mangler::BindGenerics::None);
|
|
return mangler.finalize(buffer);
|
|
|
|
// global ::= 'Mn' type // nominal type descriptor
|
|
case Kind::NominalTypeDescriptor:
|
|
mangler.append("_TMn");
|
|
mangler.mangleNominalType(cast<NominalTypeDecl>(getDecl()),
|
|
ResilienceExpansion::Minimal,
|
|
Mangler::BindGenerics::None);
|
|
return mangler.finalize(buffer);
|
|
|
|
// global ::= 'Mp' type // protocol descriptor
|
|
case Kind::ProtocolDescriptor:
|
|
mangler.append("_TMp");
|
|
mangler.mangleProtocolName(cast<ProtocolDecl>(getDecl()));
|
|
return mangler.finalize(buffer);
|
|
|
|
// global ::= 'Wo' entity
|
|
case Kind::WitnessTableOffset:
|
|
mangler.append("_TWo");
|
|
|
|
// Witness table entries for constructors always refer to the allocating
|
|
// constructor.
|
|
if (auto ctor = dyn_cast<ConstructorDecl>(getDecl()))
|
|
mangler.mangleConstructorEntity(ctor, /*isAllocating=*/true,
|
|
getResilienceExpansion(),
|
|
getUncurryLevel());
|
|
else
|
|
mangler.mangleEntity(getDecl(), getResilienceExpansion(),
|
|
getUncurryLevel());
|
|
return mangler.finalize(buffer);
|
|
|
|
// global ::= 'Wv' directness entity
|
|
case Kind::FieldOffset:
|
|
mangler.mangleFieldOffsetFull(getDecl(), isOffsetIndirect());
|
|
return mangler.finalize(buffer);
|
|
|
|
// global ::= 'WP' protocol-conformance
|
|
case Kind::DirectProtocolWitnessTable:
|
|
mangler.append("_TWP");
|
|
mangler.mangleProtocolConformance(getProtocolConformance());
|
|
return mangler.finalize(buffer);
|
|
|
|
// global ::= 'Wa' protocol-conformance
|
|
case Kind::ProtocolWitnessTableAccessFunction:
|
|
mangler.append("_TWa");
|
|
mangler.mangleProtocolConformance(getProtocolConformance());
|
|
return mangler.finalize(buffer);
|
|
|
|
// global ::= 'Wl' type protocol-conformance
|
|
case Kind::ProtocolWitnessTableLazyAccessFunction:
|
|
mangler.append("_TWl");
|
|
mangler.mangleType(getType(), ResilienceExpansion::Minimal, 0);
|
|
mangler.mangleProtocolConformance(getProtocolConformance());
|
|
return mangler.finalize(buffer);
|
|
|
|
// global ::= 'WL' type protocol-conformance
|
|
case Kind::ProtocolWitnessTableLazyCacheVariable:
|
|
mangler.append("_TWL");
|
|
mangler.mangleType(getType(), ResilienceExpansion::Minimal, 0);
|
|
mangler.mangleProtocolConformance(getProtocolConformance());
|
|
return mangler.finalize(buffer);
|
|
|
|
// global ::= 'WD' protocol-conformance
|
|
case Kind::DependentProtocolWitnessTableGenerator:
|
|
mangler.append("_TWD");
|
|
mangler.mangleProtocolConformance(getProtocolConformance());
|
|
return mangler.finalize(buffer);
|
|
|
|
// global ::= 'Wd' protocol-conformance
|
|
case Kind::DependentProtocolWitnessTableTemplate:
|
|
mangler.append("_TWd");
|
|
mangler.mangleProtocolConformance(getProtocolConformance());
|
|
return mangler.finalize(buffer);
|
|
|
|
// For all the following, this rule was imposed above:
|
|
// global ::= local-marker? entity // some identifiable thing
|
|
|
|
// entity ::= declaration // other declaration
|
|
case Kind::Function:
|
|
// As a special case, functions can have external asm names.
|
|
if (auto AsmA = getDecl()->getAttrs().getAttribute<SILGenNameAttr>()) {
|
|
mangler.append(AsmA->Name);
|
|
return mangler.finalize(buffer);
|
|
}
|
|
|
|
// Otherwise, fall through into the 'other decl' case.
|
|
SWIFT_FALLTHROUGH;
|
|
|
|
case Kind::Other:
|
|
// As a special case, Clang functions and globals don't get mangled at all.
|
|
if (auto clangDecl = getDecl()->getClangDecl()) {
|
|
if (auto namedClangDecl = dyn_cast<clang::DeclaratorDecl>(clangDecl)) {
|
|
if (auto asmLabel = namedClangDecl->getAttr<clang::AsmLabelAttr>()) {
|
|
mangler.append('\01');
|
|
mangler.append(asmLabel->getLabel());
|
|
} else if (namedClangDecl->hasAttr<clang::OverloadableAttr>()) {
|
|
// FIXME: When we can import C++, use Clang's mangler all the time.
|
|
std::string storage;
|
|
llvm::raw_string_ostream SS(storage);
|
|
mangleClangDecl(SS, namedClangDecl, getDecl()->getASTContext());
|
|
mangler.append(SS.str());
|
|
} else {
|
|
mangler.append(namedClangDecl->getName());
|
|
}
|
|
return mangler.finalize(buffer);
|
|
}
|
|
}
|
|
|
|
mangler.append("_T");
|
|
if (auto type = dyn_cast<NominalTypeDecl>(getDecl())) {
|
|
mangler.mangleNominalType(type, getResilienceExpansion(),
|
|
Mangler::BindGenerics::None);
|
|
} else if (auto ctor = dyn_cast<ConstructorDecl>(getDecl())) {
|
|
// FIXME: Hack. LinkInfo should be able to refer to the allocating
|
|
// constructor rather than inferring it here.
|
|
mangler.mangleConstructorEntity(ctor, /*isAllocating=*/true,
|
|
getResilienceExpansion(),
|
|
getUncurryLevel());
|
|
} else {
|
|
mangler.mangleEntity(getDecl(), getResilienceExpansion(), getUncurryLevel());
|
|
}
|
|
return mangler.finalize(buffer);
|
|
|
|
// An Objective-C class reference; not a swift mangling.
|
|
case Kind::ObjCClass: {
|
|
llvm::SmallString<64> TempBuffer;
|
|
mangler.append("OBJC_CLASS_$_");
|
|
StringRef Name = cast<ClassDecl>(getDecl())->getObjCRuntimeName(TempBuffer);
|
|
mangler.append(Name);
|
|
return mangler.finalize(buffer);
|
|
}
|
|
|
|
// An Objective-C metaclass reference; not a swift mangling.
|
|
case Kind::ObjCMetaclass: {
|
|
llvm::SmallString<64> TempBuffer;
|
|
mangler.append("OBJC_METACLASS_$_");
|
|
StringRef Name = cast<ClassDecl>(getDecl())->getObjCRuntimeName(TempBuffer);
|
|
mangler.append(Name);
|
|
return mangler.finalize(buffer);
|
|
}
|
|
|
|
case Kind::SILFunction:
|
|
mangler.append(getSILFunction()->getName());
|
|
return mangler.finalize(buffer);
|
|
case Kind::SILGlobalVariable:
|
|
mangler.append(getSILGlobalVariable()->getName());
|
|
return mangler.finalize(buffer);
|
|
}
|
|
llvm_unreachable("bad entity kind!");
|
|
}
|