SILValue SILGenFunction::emitGlobalFunctionRef(SILLocation loc,
SILDeclRef constant,
SILConstantInfo constantInfo) {
assert(constantInfo == getConstantInfo(constant));
// Builtins must be fully applied at the point of reference.
if (constant.hasDecl() &&
isa<BuiltinUnit>(constant.getDecl()->getDeclContext())) {
SGM.diagnose(loc.getSourceLoc(), diag::not_implemented,
"delayed application of builtin");
return SILUndef::get(constantInfo.getSILType(), SGM.M);
}
// If the constant is a thunk we haven't emitted yet, emit it.
if (!SGM.hasFunction(constant)) {
if (constant.isCurried) {
SGM.emitCurryThunk(constant);
} else if (constant.isForeignToNativeThunk()) {
SGM.emitForeignToNativeThunk(constant);
} else if (constant.isNativeToForeignThunk()) {
SGM.emitNativeToForeignThunk(constant);
} else if (constant.kind == SILDeclRef::Kind::EnumElement) {
SGM.emitEnumConstructor(cast<EnumElementDecl>(constant.getDecl()));
}
}
auto f = SGM.getFunction(constant, NotForDefinition);
assert(f->getLoweredFunctionType() == constantInfo.SILFnType);
return B.createFunctionRef(loc, f);
}
SILValue SILGenFunction::emitGlobalFunctionRef(SILLocation loc,
SILDeclRef constant,
SILConstantInfo constantInfo) {
assert(constantInfo == getConstantInfo(constant));
// Builtins must be fully applied at the point of reference.
if (constant.hasDecl() &&
isa<BuiltinUnit>(constant.getDecl()->getDeclContext())) {
SGM.diagnose(loc.getSourceLoc(), diag::not_implemented,
"delayed application of builtin");
return SILUndef::get(constantInfo.getSILType(), SGM.M);
}
// If the constant is a thunk we haven't emitted yet, emit it.
if (!SGM.hasFunction(constant)) {
if (constant.isCurried) {
auto vd = constant.getDecl();
// Reference the next uncurrying level of the function.
SILDeclRef next = SILDeclRef(vd, constant.kind,
SILDeclRef::ConstructAtBestResilienceExpansion,
constant.uncurryLevel + 1);
// If the function is fully uncurried and natively foreign, reference its
// foreign entry point.
if (!next.isCurried) {
if (requiresForeignToNativeThunk(vd))
next = next.asForeign();
}
// Preserve whether the curry thunks lead to a direct reference to the
// method implementation.
next = next.asDirectReference(constant.isDirectReference);
SGM.emitCurryThunk(vd, constant, next);
}
// Otherwise, if this is a calling convention thunk we haven't emitted yet,
// emit it.
else if (constant.isForeignToNativeThunk()) {
SGM.emitForeignToNativeThunk(constant);
} else if (constant.isNativeToForeignThunk()) {
SGM.emitNativeToForeignThunk(constant);
} else if (constant.kind == SILDeclRef::Kind::EnumElement) {
SGM.emitEnumConstructor(cast<EnumElementDecl>(constant.getDecl()));
}
}
auto f = SGM.getFunction(constant, NotForDefinition);
assert(f->getLoweredFunctionType() == constantInfo.SILFnType);
return B.createFunctionRef(loc, f);
}
static std::string mangleConstant(SILDeclRef c, SILDeclRef::ManglingKind Kind) {
using namespace Mangle;
Mangler mangler;
// Almost everything below gets one of the common prefixes:
// mangled-name ::= '_T' global // Native symbol
// mangled-name ::= '_TTo' global // ObjC interop thunk
// mangled-name ::= '_TTO' global // Foreign function thunk
// mangled-name ::= '_TTd' global // Direct
StringRef introducer = "_T";
switch (Kind) {
case SILDeclRef::ManglingKind::Default:
if (c.isForeign) {
introducer = "_TTo";
} else if (c.isDirectReference) {
introducer = "_TTd";
} else if (c.isForeignToNativeThunk()) {
introducer = "_TTO";
}
break;
case SILDeclRef::ManglingKind::VTableMethod:
introducer = "_TTV";
break;
case SILDeclRef::ManglingKind::DynamicThunk:
introducer = "_TTD";
break;
}
// As a special case, Clang functions and globals don't get mangled at all.
if (c.hasDecl()) {
if (auto clangDecl = c.getDecl()->getClangDecl()) {
if (!c.isForeignToNativeThunk() && !c.isNativeToForeignThunk()
&& !c.isCurried) {
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>()) {
std::string storage;
llvm::raw_string_ostream SS(storage);
// FIXME: When we can import C++, use Clang's mangler all the time.
mangleClangDecl(SS, namedClangDecl,
c.getDecl()->getASTContext());
mangler.append(SS.str());
} else {
mangler.append(namedClangDecl->getName());
}
return mangler.finalize();
}
}
}
}
switch (c.kind) {
// entity ::= declaration // other declaration
case SILDeclRef::Kind::Func:
if (!c.hasDecl()) {
mangler.append(introducer);
mangler.mangleClosureEntity(c.getAbstractClosureExpr(),
c.uncurryLevel);
return mangler.finalize();
}
// As a special case, functions can have manually mangled names.
// Use the SILGen name only for the original non-thunked, non-curried entry
// point.
if (auto NameA = c.getDecl()->getAttrs().getAttribute<SILGenNameAttr>())
if (!c.isForeignToNativeThunk() && !c.isNativeToForeignThunk()
&& !c.isCurried) {
mangler.append(NameA->Name);
return mangler.finalize();
}
// Use a given cdecl name for native-to-foreign thunks.
if (auto CDeclA = c.getDecl()->getAttrs().getAttribute<CDeclAttr>())
if (c.isNativeToForeignThunk()) {
mangler.append(CDeclA->Name);
return mangler.finalize();
}
// Otherwise, fall through into the 'other decl' case.
SWIFT_FALLTHROUGH;
case SILDeclRef::Kind::EnumElement:
mangler.append(introducer);
mangler.mangleEntity(c.getDecl(), c.uncurryLevel);
return mangler.finalize();
// entity ::= context 'D' // deallocating destructor
case SILDeclRef::Kind::Deallocator:
mangler.append(introducer);
mangler.mangleDestructorEntity(cast<DestructorDecl>(c.getDecl()),
/*isDeallocating*/ true);
return mangler.finalize();
// entity ::= context 'd' // destroying destructor
case SILDeclRef::Kind::Destroyer:
mangler.append(introducer);
mangler.mangleDestructorEntity(cast<DestructorDecl>(c.getDecl()),
/*isDeallocating*/ false);
return mangler.finalize();
// entity ::= context 'C' type // allocating constructor
case SILDeclRef::Kind::Allocator:
mangler.append(introducer);
mangler.mangleConstructorEntity(cast<ConstructorDecl>(c.getDecl()),
/*allocating*/ true,
c.uncurryLevel);
return mangler.finalize();
// entity ::= context 'c' type // initializing constructor
case SILDeclRef::Kind::Initializer:
mangler.append(introducer);
mangler.mangleConstructorEntity(cast<ConstructorDecl>(c.getDecl()),
/*allocating*/ false,
c.uncurryLevel);
return mangler.finalize();
// entity ::= declaration 'e' // ivar initializer
// entity ::= declaration 'E' // ivar destroyer
case SILDeclRef::Kind::IVarInitializer:
case SILDeclRef::Kind::IVarDestroyer:
mangler.append(introducer);
mangler.mangleIVarInitDestroyEntity(
cast<ClassDecl>(c.getDecl()),
c.kind == SILDeclRef::Kind::IVarDestroyer);
return mangler.finalize();
// entity ::= declaration 'a' // addressor
case SILDeclRef::Kind::GlobalAccessor:
mangler.append(introducer);
mangler.mangleAddressorEntity(c.getDecl());
return mangler.finalize();
// entity ::= declaration 'G' // getter
case SILDeclRef::Kind::GlobalGetter:
mangler.append(introducer);
mangler.mangleGlobalGetterEntity(c.getDecl());
return mangler.finalize();
// entity ::= context 'e' index // default arg generator
case SILDeclRef::Kind::DefaultArgGenerator:
mangler.append(introducer);
mangler.mangleDefaultArgumentEntity(cast<AbstractFunctionDecl>(c.getDecl()),
c.defaultArgIndex);
return mangler.finalize();
// entity ::= 'I' declaration 'i' // stored property initializer
case SILDeclRef::Kind::StoredPropertyInitializer:
mangler.append(introducer);
mangler.mangleInitializerEntity(cast<VarDecl>(c.getDecl()));
return mangler.finalize();
}
llvm_unreachable("bad entity kind!");
}
static std::string mangleConstant(SILDeclRef c, SILDeclRef::ManglingKind Kind) {
using namespace NewMangling;
ASTMangler mangler;
// As a special case, Clang functions and globals don't get mangled at all.
if (c.hasDecl()) {
if (auto clangDecl = c.getDecl()->getClangDecl()) {
if (!c.isForeignToNativeThunk() && !c.isNativeToForeignThunk()
&& !c.isCurried) {
if (auto namedClangDecl = dyn_cast<clang::DeclaratorDecl>(clangDecl)) {
if (auto asmLabel = namedClangDecl->getAttr<clang::AsmLabelAttr>()) {
std::string s(1, '\01');
s += asmLabel->getLabel();
return s;
} else if (namedClangDecl->hasAttr<clang::OverloadableAttr>()) {
std::string storage;
llvm::raw_string_ostream SS(storage);
// FIXME: When we can import C++, use Clang's mangler all the time.
mangleClangDecl(SS, namedClangDecl,
c.getDecl()->getASTContext());
return SS.str();
}
return namedClangDecl->getName();
}
}
}
}
ASTMangler::SymbolKind SKind = ASTMangler::SymbolKind::Default;
switch (Kind) {
case SILDeclRef::ManglingKind::Default:
if (c.isForeign) {
SKind = ASTMangler::SymbolKind::SwiftAsObjCThunk;
} else if (c.isDirectReference) {
SKind = ASTMangler::SymbolKind::DirectMethodReferenceThunk;
} else if (c.isForeignToNativeThunk()) {
SKind = ASTMangler::SymbolKind::ObjCAsSwiftThunk;
}
break;
case SILDeclRef::ManglingKind::VTableMethod:
SKind = ASTMangler::SymbolKind::VTableMethod;
break;
case SILDeclRef::ManglingKind::DynamicThunk:
SKind = ASTMangler::SymbolKind::DynamicThunk;
break;
}
switch (c.kind) {
case SILDeclRef::Kind::Func:
if (!c.hasDecl())
return mangler.mangleClosureEntity(c.getAbstractClosureExpr(), SKind);
// As a special case, functions can have manually mangled names.
// Use the SILGen name only for the original non-thunked, non-curried entry
// point.
if (auto NameA = c.getDecl()->getAttrs().getAttribute<SILGenNameAttr>())
if (!c.isForeignToNativeThunk() && !c.isNativeToForeignThunk()
&& !c.isCurried) {
return NameA->Name;
}
// Use a given cdecl name for native-to-foreign thunks.
if (auto CDeclA = c.getDecl()->getAttrs().getAttribute<CDeclAttr>())
if (c.isNativeToForeignThunk()) {
return CDeclA->Name;
}
// Otherwise, fall through into the 'other decl' case.
SWIFT_FALLTHROUGH;
case SILDeclRef::Kind::EnumElement:
return mangler.mangleEntity(c.getDecl(), c.isCurried, SKind);
case SILDeclRef::Kind::Deallocator:
assert(!c.isCurried);
return mangler.mangleDestructorEntity(cast<DestructorDecl>(c.getDecl()),
/*isDeallocating*/ true,
SKind);
case SILDeclRef::Kind::Destroyer:
assert(!c.isCurried);
return mangler.mangleDestructorEntity(cast<DestructorDecl>(c.getDecl()),
/*isDeallocating*/ false,
SKind);
case SILDeclRef::Kind::Allocator:
return mangler.mangleConstructorEntity(cast<ConstructorDecl>(c.getDecl()),
/*allocating*/ true,
c.isCurried,
SKind);
case SILDeclRef::Kind::Initializer:
return mangler.mangleConstructorEntity(cast<ConstructorDecl>(c.getDecl()),
/*allocating*/ false,
c.isCurried,
SKind);
case SILDeclRef::Kind::IVarInitializer:
case SILDeclRef::Kind::IVarDestroyer:
assert(!c.isCurried);
return mangler.mangleIVarInitDestroyEntity(cast<ClassDecl>(c.getDecl()),
c.kind == SILDeclRef::Kind::IVarDestroyer,
SKind);
case SILDeclRef::Kind::GlobalAccessor:
assert(!c.isCurried);
return mangler.mangleAccessorEntity(AccessorKind::IsMutableAddressor,
AddressorKind::Unsafe,
c.getDecl(),
/*isStatic*/ false,
SKind);
case SILDeclRef::Kind::GlobalGetter:
assert(!c.isCurried);
return mangler.mangleGlobalGetterEntity(c.getDecl(), SKind);
case SILDeclRef::Kind::DefaultArgGenerator:
assert(!c.isCurried);
return mangler.mangleDefaultArgumentEntity(
cast<AbstractFunctionDecl>(c.getDecl()),
c.defaultArgIndex,
SKind);
case SILDeclRef::Kind::StoredPropertyInitializer:
assert(!c.isCurried);
return mangler.mangleInitializerEntity(cast<VarDecl>(c.getDecl()), SKind);
}
llvm_unreachable("bad entity kind!");
}