averello/swift-mirror
1
0
Fork 0
mirror of https://github.com/apple/swift.git synced 2025-12-21 12:14:44 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
8adaab0233f38dc7a55df3b51e36d03842ef10c4
swift-mirror/lib/IRGen/IRGenDebugInfo.cpp
Joe Groff 8adaab0233 Fold ExtInfo::isThin and ::isBlock into a "Representation" enum. 
These bits are orthogonal to each other, so combine them into one, and diagnose attempts to produce a type that's both. Spot-fix a bunch of places this revealed by inspection that we would have crashed in SILGen or IRGen if blocks were be handled.

Swift SVN r16088
2014-04-09 00:37:26 +00:00

1537 lines
57 KiB
C++
Raw Blame History

//===--- IRGenDebugInfo.h - Debug Info Support-----------------------------===//
//
// 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 IR debug info generation for Swift.
//
//===----------------------------------------------------------------------===//
#include "IRGenDebugInfo.h"
#include "GenType.h"
#include "Linking.h"
#include "swift/AST/Expr.h"
#include "swift/AST/IRGenOptions.h"
#include "swift/AST/Mangle.h"
#include "swift/AST/Module.h"
#include "swift/AST/ModuleLoader.h"
#include "swift/AST/Pattern.h"
#include "swift/Basic/Dwarf.h"
#include "swift/Basic/Punycode.h"
#include "swift/Basic/SourceManager.h"
#include "swift/Basic/Version.h"
#include "swift/ClangImporter/ClangImporter.h"
#include "swift/SIL/SILArgument.h"
#include "swift/SIL/SILBasicBlock.h"
#include "swift/SIL/SILDebugScope.h"
#include "swift/SIL/SILModule.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/Decl.h"
#include "clang/Basic/Module.h"
#include "clang/Basic/SourceLocation.h"
#include "clang/Basic/SourceManager.h"
#include "clang/Basic/TargetInfo.h"
#include "llvm/Config/config.h"
#include "llvm/IR/DebugInfo.h"
#include "llvm/IR/Module.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/raw_ostream.h"
using namespace swift;
using namespace irgen;
/// Strdup a raw char array using the bump pointer.
StringRef IRGenDebugInfo::BumpAllocatedString(const char* Data, size_t Length) {
char *Ptr = DebugInfoNames.Allocate<char>(Length);
memcpy(Ptr, Data, Length);
return StringRef(Ptr, Length);
}
/// Strdup S using the bump pointer.
StringRef IRGenDebugInfo::BumpAllocatedString(std::string S) {
return BumpAllocatedString(S.c_str(), S.length());
}
/// Strdup StringRef S using the bump pointer.
StringRef IRGenDebugInfo::BumpAllocatedString(StringRef S) {
return BumpAllocatedString(S.data(), S.size());
}
IRGenDebugInfo::IRGenDebugInfo(const IRGenOptions &Opts,
ClangImporter &CI,
IRGenModule &IGM,
llvm::Module &M)
: Opts(Opts),
CI(CI),
SM(IGM.Context.SourceMgr),
M(M),
DBuilder(M),
IGM(IGM),
MetadataTypeDecl(nullptr),
LastLoc({}),
LastScope(nullptr)
{
assert(Opts.DebugInfo);
StringRef Dir, Filename;
if (Opts.MainInputFilename.empty()) {
Filename = "<unknown>";
Dir = getCurrentDirname();
} else {
// Separate path and filename.
Filename =
BumpAllocatedString(llvm::sys::path::filename(Opts.MainInputFilename));
llvm::SmallString<512> Path(Opts.MainInputFilename);
llvm::sys::path::remove_filename(Path);
llvm::sys::fs::make_absolute(Path);
llvm::SmallString<512> NPath;
llvm::sys::path::native(Twine(Path), NPath);
Dir = BumpAllocatedString(NPath);
}
// The fallback file.
MainFilename = Dir;
llvm::sys::path::append(MainFilename, Filename);
MainFile = getOrCreateFile(MainFilename.c_str());
unsigned Lang = DW_LANG_Swift;
StringRef Producer = BumpAllocatedString(version::getSwiftFullVersion());
bool IsOptimized = Opts.OptLevel > 0;
StringRef Flags = Opts.DWARFDebugFlags;
// FIXME.
unsigned RuntimeVersion = 1;
// No split DWARF on Darwin.
StringRef SplitName = StringRef();
TheCU = DBuilder.createCompileUnit(Lang, Filename, Dir, Producer,
IsOptimized, Flags, RuntimeVersion,
SplitName);
if (IGM.SILMod->lookUpFunction(SWIFT_ENTRY_POINT_FUNCTION)) {
IsLibrary = false;
EntryPointFn =
DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_subroutine_type,
SWIFT_ENTRY_POINT_FUNCTION,
MainFile, MainFile, 0);
}
}
static const char* getFilenameFromDC(const DeclContext *DC) {
if (auto LF = dyn_cast<LoadedFile>(DC)) {
// FIXME: Today, the subclasses of LoadedFile happen to return StringRefs
// that are backed by null-terminated strings, but that's certainly not
// guaranteed in the future.
StringRef Fn = LF->getFilename();
assert(((Fn.size() == 0) ||
(Fn.data()[Fn.size()] == '\0')) && "not a C string");
return Fn.data();
} if (auto SF = dyn_cast<SourceFile>(DC))
return SF->getFilename().data();
else if (auto M = dyn_cast<Module>(DC))
return M->getModuleFilename().data();
else
return nullptr;
}
Location getDeserializedLoc(Pattern*) { return {}; }
Location getDeserializedLoc(Expr*) { return {}; }
Location getDeserializedLoc(Stmt*) { return {}; }
Location getDeserializedLoc(Decl* D) {
Location L = {};
const DeclContext *DC = D->getDeclContext()->getModuleScopeContext();
if (const char* Filename = getFilenameFromDC(DC)) {
L.Filename = Filename;
L.Line = 1;
}
return L;
}
Location getLoc(SourceManager &SM, SourceLoc Loc) {
Location L = {};
unsigned BufferID = SM.findBufferContainingLoc(Loc);
L.Filename = SM->getMemoryBuffer(BufferID)->getBufferIdentifier();
std::tie(L.Line, L.Col) = SM.getLineAndColumn(Loc, BufferID);
return L;
}
/// Use the SM to figure out the actual line/column of a SourceLoc.
template<typename WithLoc>
Location getLoc(SourceManager &SM, WithLoc *S, bool End = false) {
Location L = {};
if (S == nullptr)
return L;
SourceLoc Loc = End ? S->getEndLoc() : S->getStartLoc();
if (Loc.isInvalid())
// This may be a deserialized or clang-imported decl. And modules
// don't come with SourceLocs right now. Get at least the name of
// the module.
return getDeserializedLoc(S);
return getLoc(SM, Loc);
}
/// getLocForLinetable - extract the start location from a SILLocation.
///
/// This returns a FullLocation, which contains the location that
/// should be used for the linetable and the "true" AST location (used
/// for, e.g., variable declarations).
static FullLocation
getLocation(SourceManager &SM, Optional<SILLocation> OptLoc) {
if (!OptLoc)
return {};
SILLocation Loc = OptLoc.getValue();
bool UseEnd = Loc.alwaysPointsToEnd();
if (Loc.isNull() || Loc.isAutoGenerated()) return {};
if (Expr *E = Loc.getAsASTNode<Expr>()) {
// Code that has an autoclosure as location should not show up in
// the line table (rdar://problem/14627460). Note also that the
// closure function still has a valid DW_AT_decl_line. Depending
// on how we decide to resolve rdar://problem/14627460, we may
// want to use the regular getLoc instead and rather use the
// column info.
auto ELoc = getLoc(SM, E, UseEnd);
if (isa<AutoClosureExpr>(E))
return {{}, ELoc};
return {ELoc, ELoc};
}
if (Pattern* P = Loc.getAsASTNode<Pattern>()) {
auto PLoc = getLoc(SM, P, UseEnd);
return {PLoc, PLoc};
}
if (Stmt* S = Loc.getAsASTNode<Stmt>()) {
auto SLoc = getLoc(SM, S, UseEnd);
auto LinetableLoc = (Loc.getKind() == SILLocation::CleanupKind)
? getLoc(SM, S, true) : SLoc;
return {LinetableLoc, SLoc};
}
if (Decl* D = Loc.getAsASTNode<Decl>()) {
auto DLoc = getLoc(SM, D, UseEnd);
auto LinetableLoc = DLoc;
if (Loc.isInPrologue())
LinetableLoc = {};
// For return and cleanup code SILLocation points to the start,
// because this is where we want diagnostics to appear. For the
// line table, we want them to point to the end of the Decl.
else if (Loc.getKind() == SILLocation::ImplicitReturnKind ||
Loc.getKind() == SILLocation::CleanupKind)
LinetableLoc = getLoc(SM, D, true);
return {LinetableLoc, DLoc};
}
llvm_unreachable("unexpected location type");
}
/// Determine whether this debug scope belongs to an explicit closure.
static bool isExplicitClosure(SILDebugScope *DS) {
if (DS)
if (Expr *E = DS->Loc.getAsASTNode<Expr>())
if (isa<ClosureExpr>(E))
return true;
return false;
}
/// Determine whether this location is some kind of closure.
static bool isAbstractClosure(const SILLocation &Loc) {
if (Expr *E = Loc.getAsASTNode<Expr>())
if (isa<AbstractClosureExpr>(E))
return true;
return false;
}
void IRGenDebugInfo::setCurrentLoc(IRBuilder& Builder,
SILDebugScope *DS,
Optional<SILLocation> Loc) {
// In LLVM IR, the function prologue has neither location nor scope.
if (Loc && Loc->isInPrologue()) return;
llvm::DIDescriptor Scope = getOrCreateScope(DS);
if (!Scope.Verify()) return;
FullLocation L = getLocation(SM, Loc);
if (L.LocForLinetable.Filename &&
L.LocForLinetable.Filename !=
getLocation(SM, DS->Loc).LocForLinetable.Filename) {
// We changed files in the middle of a scope. This happens, for
// example, when constructors are inlined. Create a new scope to
// reflect this.
auto File = getOrCreateFile(L.LocForLinetable.Filename);
Scope = DBuilder.createLexicalBlockFile(Scope, File);
}
// Both the code that is used to set up a closure object and the
// (beginning of) the closure itself has the AbstractClosureExpr as
// location. We are only interested in the latter case and want to
// ignore the setup code.
//
// callWithClosure(
// { // <-- a breakpoint here should only stop inside of the closure.
// foo();
// })
//
// The actual closure has a closure expression as scope.
if (Loc && isAbstractClosure(*Loc) && !isAbstractClosure(DS->Loc))
return;
if (L.LocForLinetable.Line == 0 && DS == LastScope) {
// Reuse the last source location if we are still in the same
// scope to get a more contiguous line table.
L = LastLoc;
}
LastLoc = L;
LastScope = DS;
llvm::MDNode *InlinedAt = 0;
auto DL = llvm::DebugLoc::get(L.LocForLinetable.Line, L.LocForLinetable.Col,
Scope, InlinedAt);
// TODO: Write a strongly-worded letter to the person that came up
// with a pair of functions spelled "get" and "Set".
Builder.SetCurrentDebugLocation(DL);
}
/// getOrCreateScope - Translate a SILDebugScope into an llvm::DIDescriptor.
llvm::DIDescriptor IRGenDebugInfo::getOrCreateScope(SILDebugScope *DS) {
if (DS == 0)
return MainFile;
// Try to find it in the cache first.
auto CachedScope = ScopeCache.find(DS);
if (CachedScope != ScopeCache.end())
return llvm::DIDescriptor(cast<llvm::MDNode>(CachedScope->second));
Location L = getLocation(SM, DS->Loc).Loc;
llvm::DIFile File = getOrCreateFile(L.Filename);
llvm::DIDescriptor Parent = getOrCreateScope(DS->Parent);
if (!Parent)
Parent = File;
llvm::DILexicalBlock DScope =
DBuilder.createLexicalBlock(Parent, File, L.Line, L.Col, 0);
// Cache it.
ScopeCache[DS] = llvm::WeakVH(DScope);
return DScope;
}
/// getCurrentDirname - Return the current working directory.
StringRef IRGenDebugInfo::getCurrentDirname() {
// FIXME: Clang has a global option to set the compilation
// directory. Do we have something similar for swift?
if (!CWDName.empty())
return CWDName;
llvm::SmallString<256> CWD;
llvm::sys::fs::current_path(CWD);
return BumpAllocatedString(CWD.str());
}
/// getOrCreateFile - Translate filenames into DIFiles.
llvm::DIFile IRGenDebugInfo::getOrCreateFile(const char *Filename) {
if (!Filename)
return MainFile;
// Look in the cache first.
auto CachedFile = DIFileCache.find(Filename);
if (CachedFile != DIFileCache.end()) {
// Verify that the information still exists.
if (llvm::Value *V = CachedFile->second)
return llvm::DIFile(cast<llvm::MDNode>(V));
}
// Create a new one.
StringRef File = BumpAllocatedString(llvm::sys::path::filename(Filename));
llvm::SmallString<512> Path(Filename);
llvm::sys::path::remove_filename(Path);
llvm::error_code ec = llvm::sys::fs::make_absolute(Path);
// Basically ignore any error.
assert(ec == llvm::errc::success);
(void)ec; // Silence the unused variable warning
llvm::DIFile F =
DBuilder.createFile(File, BumpAllocatedString(Path));
// Cache it.
DIFileCache[Filename] = llvm::WeakVH(F);
return F;
}
/// Attempt to figure out the unmangled name of a function.
StringRef IRGenDebugInfo::getName(const FuncDecl &FD) {
// Getters and Setters are anonymous functions, so we forge a name
// using its parent declaration.
if (FD.isAccessor())
if (ValueDecl *VD = FD.getAccessorStorageDecl()) {
const char *Kind;
switch (FD.getAccessorKind()) {
case AccessorKind::NotAccessor: llvm_unreachable("this is an accessor");
case AccessorKind::IsGetter: Kind = ".get"; break;
case AccessorKind::IsSetter: Kind = ".set"; break;
case AccessorKind::IsWillSet: Kind = ".willset"; break;
case AccessorKind::IsDidSet: Kind = ".didset"; break;
}
SmallVector<char, 64> Buf;
StringRef Name = (VD->getName().str() +Twine(Kind)).toStringRef(Buf);
return BumpAllocatedString(Name);
}
if (FD.hasName())
return FD.getName().str();
return StringRef();
}
/// Attempt to figure out the unmangled name of a function.
StringRef IRGenDebugInfo::getName(SILLocation L) {
if (L.isNull())
return StringRef();
if (FuncDecl *FD = L.getAsASTNode<FuncDecl>())
return getName(*FD);
if (L.isASTNode<ConstructorDecl>())
return "init";
return StringRef();
}
static CanSILFunctionType getFunctionType(SILType SILTy) {
if (!SILTy) return CanSILFunctionType();
auto FnTy = SILTy.getAs<SILFunctionType>();
if (!FnTy) {
DEBUG(llvm::dbgs() << "Unexpected function type: "; SILTy.dump();
llvm::dbgs() << "\n");
return CanSILFunctionType();
}
return FnTy;
}
/// Create a single parameter type and push it.
void IRGenDebugInfo::
createParameterType(llvm::SmallVectorImpl<llvm::Value*>& Parameters,
SILType type,
llvm::DIDescriptor Scope,
DeclContext* DeclCtx) {
// FIXME: This use of getSwiftType() is extremely suspect.
DebugTypeInfo DTy(type.getSwiftType(), IGM.getTypeInfo(type), DeclCtx);
Parameters.push_back(getOrCreateType(DTy, Scope));
}
/// Create the array of function parameters for FnTy. SIL Version.
llvm::DIArray IRGenDebugInfo::createParameterTypes(SILType SILTy,
llvm::DIDescriptor Scope,
DeclContext* DeclCtx) {
if (!SILTy) return llvm::DIArray();
return createParameterTypes(SILTy.castTo<SILFunctionType>(), Scope, DeclCtx);
}
/// Create the array of function parameters for a function type.
llvm::DIArray IRGenDebugInfo::createParameterTypes(CanSILFunctionType FnTy,
llvm::DIDescriptor Scope,
DeclContext* DeclCtx) {
SmallVector<llvm::Value *, 16> Parameters;
GenericContextScope scope(IGM, FnTy->getGenericSignature());
// The function return type is the first element in the list.
createParameterType(Parameters,
FnTy->getSemanticInterfaceResultSILType(),
Scope, DeclCtx);
// Actually, the input type is either a single type or a tuple
// type. We currently represent a function with one n-tuple argument
// as an n-ary function.
for (auto Param : FnTy->getInterfaceParameters())
createParameterType(Parameters, Param.getSILType(),
Scope, DeclCtx);
return DBuilder.getOrCreateArray(Parameters);
}
void IRGenDebugInfo::emitFunction(SILModule &SILMod, SILDebugScope *DS,
llvm::Function *Fn,
AbstractCC CC, SILType SILTy,
DeclContext *DeclCtx) {
StringRef Name;
Location L = {};
Location PrologLoc = {}; // The source line used for the function prologue.
if (DS) {
Name = getName(DS->Loc);
auto FL = getLocation(SM, DS->Loc);
L = FL.Loc;
// ObjC thunks should not show up in the linetable, because we
// never want to set a breakpoint there.
if (CC != AbstractCC::ObjCMethod)
PrologLoc = FL.LocForLinetable;
}
assert(Fn);
auto LinkageName = Fn->getName();
auto File = getOrCreateFile(L.Filename);
// This placeholder scope gets RAUW'd when the namespaces are
// created after we are finished with the entire module.
auto Scope = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_subroutine_type,
LinkageName, File, File, 0);
auto Line = L.Line;
// We know that top_level_code always comes from MainFile.
if (LinkageName == SWIFT_ENTRY_POINT_FUNCTION) {
if (!L.Filename) File = MainFile;
Line = 1;
}
CanSILFunctionType FnTy = getFunctionType(SILTy);
auto Params = createParameterTypes(SILTy, Scope, DeclCtx);
llvm::DICompositeType DIFnTy = DBuilder.createSubroutineType(File, Params);
llvm::DIArray TemplateParameters;
llvm::DISubprogram Decl;
// Various flags
bool IsLocalToUnit = false;
bool IsDefinition = true;
bool IsOptimized = Opts.OptLevel > 0;
unsigned Flags = 0;
// Mark everything that is not visible from the source code (i.e.,
// does not have a Swift name) as artificial, so the debugger can
// ignore it. Explicit closures are exempt from this rule. We also
// make an exception for top_level_code, which albeit it does not
// have a Swift name, it does appear prominently in the source code.
if (Name.empty() && LinkageName != SWIFT_ENTRY_POINT_FUNCTION
&& !isExplicitClosure(DS))
Flags |= llvm::DIDescriptor::FlagArtificial;
if (FnTy && FnTy->getRepresentation() == FunctionType::Representation::Block)
Flags |= llvm::DIDescriptor::FlagAppleBlock;
switch (CC) {
// FIXME: We need to invent new DWARF attributes for the CC, but we
// can't do that without patching the LLVM backend.
// Hijacking a completely different field for now.
case AbstractCC::C:
case AbstractCC::ObjCMethod:
IsLocalToUnit = true;
break;
case AbstractCC::Method:
case AbstractCC::Freestanding:
case AbstractCC::WitnessMethod:
IsLocalToUnit = false;
}
llvm::DISubprogram SP =
DBuilder.createFunction(Scope, Name, LinkageName, File, Line,
DIFnTy, IsLocalToUnit, IsDefinition,
PrologLoc.Line,
Flags, IsOptimized, Fn, TemplateParameters, Decl);
ScopeCache[DS] = llvm::WeakVH(SP);
Functions[LinkageName] = llvm::WeakVH(SP);
// RAUW the entry point function forward declaration with the real thing.
if (LinkageName == SWIFT_ENTRY_POINT_FUNCTION)
EntryPointFn->replaceAllUsesWith(SP);
}
void IRGenDebugInfo::eraseFunction(llvm::Function *Fn) {
Functions.erase(Fn->getName());
}
static bool isNonAscii(StringRef str) {
for (unsigned char c : str) {
if (c >= 0x80)
return true;
}
return false;
}
// Mangle a single non-operator identifier.
static void mangleIdent(llvm::raw_string_ostream &OS, StringRef Id) {
// If the identifier contains non-ASCII character, we mangle with an initial
// X and Punycode the identifier string.
llvm::SmallString<32> PunycodeBuf;
if (isNonAscii(Id)) {
OS << 'X';
Punycode::encodePunycode(Id, PunycodeBuf);
Id = PunycodeBuf;
}
OS << Id.size() << Id;
OS.flush();
return;
}
/// The DWARF output for import decls is similar to that of a using
/// directive in C++:
/// import Foundation
/// -->
/// 0: DW_TAG_imported_module
/// DW_AT_import(*1)
/// 1: DW_TAG_namespace
/// DW_AT_name("Foundation")
///
void IRGenDebugInfo::emitImport(ImportDecl *D) {
// Imports are visited after SILFunctions.
llvm::DIScope Namespace = MainFile;
Module *M = IGM.Context.getModule(D->getFullAccessPath());
assert(M && "Could not find module for import decl.");
if (!M) return;
auto File = getOrCreateFile(getFilenameFromDC(M->getFiles().front()));
std::string Printed, Mangled("_T");
{
llvm::raw_string_ostream MS(Mangled), PS(Printed);
bool first = true;
for (auto elt : D->getModulePath()) {
auto Component = elt.first.str();
// We model each component of the access path as a namespace.
if (first && Component == D->getASTContext().StdlibModuleName.str())
MS << "S";
else
mangleIdent(MS, Component);
Namespace = getOrCreateNamespace(Namespace, Component, File, 1);
if (first) first = false;
else PS << '.';
PS << Component;
}
}
StringRef Name = BumpAllocatedString(Printed);
createImportedModule(Name, Mangled, llvm::DINameSpace(Namespace));
}
// Create an imported module and import declarations for all functions
// from that module.
void IRGenDebugInfo::createImportedModule(StringRef Name, StringRef Mangled,
llvm::DINameSpace Namespace) {
// This is bending the rules a little bit, but we are creating the
// imported module with the location of the imported module instead
// of the location of the import statement. Dsymustil elides
// namespaces without children, so all that's left is the
// DW_TAG_imported_module.
llvm::DIScope File;
{
llvm::SmallString<512> Path(Namespace.getDirectory());
llvm::sys::path::append(Path, Namespace.getFilename());
File = getOrCreateFile(Path.c_str());
}
auto Import = DBuilder.createImportedModule(File, Namespace, 1);
// Add all functions that belong to this namespace to it.
//
// TODO: Since we have the mangled names anyway, this part is purely
// cosmetic and we may consider removing it.
for (auto F = Functions.lower_bound(Mangled); F != Functions.end(); ++F) {
if (Mangled != F->first.substr(0, Mangled.size()))
break;
auto SP = llvm::DISubprogram(cast<llvm::MDNode>(F->second));
assert(SP.Verify());
// RAUW the context of the function with the namespace.
auto Scope = SP.getContext().resolve(DIRefMap);
if (Scope.isType() && llvm::DIType(Scope).isForwardDecl())
Scope->replaceAllUsesWith(Namespace);
DBuilder.createImportedDeclaration(llvm::DIScope(Import), SP, 1);
}
}
/// Return a cached namespace for a mangled access path or create a new one.
llvm::DIScope IRGenDebugInfo::getOrCreateNamespace(llvm::DIScope Namespace,
std::string MangledName,
llvm::DIFile File,
unsigned Line) {
// Look in the cache first.
auto CachedNS = DINameSpaceCache.find(MangledName);
if (CachedNS != DINameSpaceCache.end())
// Verify that the information still exists.
if (llvm::Value *Val = CachedNS->second)
return llvm::DINameSpace(cast<llvm::MDNode>(Val));
auto NS = DBuilder.createNameSpace(Namespace, MangledName, File, Line);
DINameSpaceCache[MangledName] = llvm::WeakVH(NS);
return NS;
}
void IRGenDebugInfo::emitFunction(SILFunction *SILFn, llvm::Function *Fn) {
if (isAvailableExternally(SILFn->getLinkage()))
return;
emitFunction(SILFn->getModule(),
SILFn->getDebugScope(), Fn,
SILFn->getAbstractCC(),
SILFn->getLoweredType(),
SILFn->getDeclContext());
}
void IRGenDebugInfo::emitArtificialFunction(SILModule &SILMod,
IRBuilder &Builder,
llvm::Function *Fn,
SILType SILTy) {
RegularLocation ALoc = RegularLocation::getAutoGeneratedLocation();
SILDebugScope *Scope = new (SILMod) SILDebugScope(ALoc);
emitFunction(SILMod, Scope, Fn, AbstractCC::Freestanding, SILTy);
setCurrentLoc(Builder, Scope);
}
TypeAliasDecl *IRGenDebugInfo::getMetadataType() {
if (!MetadataTypeDecl)
MetadataTypeDecl = new (IGM.Context)
TypeAliasDecl(SourceLoc(),
IGM.Context.getIdentifier("$swift.type"), SourceLoc(),
TypeLoc::withoutLoc(IGM.Context.TheRawPointerType),
IGM.Context.TheBuiltinModule);
return MetadataTypeDecl;
}
void IRGenDebugInfo::
emitTypeMetadata(IRGenFunction &IGF, llvm::Value *Metadata, StringRef Name) {
auto TName = BumpAllocatedString(("$swift.type."+Name).str());
DebugTypeInfo DTI(getMetadataType(),
(Size)CI.getTargetInfo().getPointerWidth(0),
(Alignment)CI.getTargetInfo().getPointerAlign(0));
emitVariableDeclaration(IGF.Builder, Metadata, DTI,
IGF.getDebugScope(),
TName, llvm::dwarf::DW_TAG_auto_variable, 0,
// swift.type is a already pointer type,
// having a shadow copy doesn't add another
// layer of indirection.
DirectValue, ArtificialValue);
}
void IRGenDebugInfo::emitStackVariableDeclaration(IRBuilder& B,
llvm::Value *Storage,
DebugTypeInfo Ty,
SILDebugScope *DS,
StringRef Name,
IndirectionKind Indirection) {
emitVariableDeclaration(B, Storage, Ty, DS, Name,
llvm::dwarf::DW_TAG_auto_variable,
0, Indirection, RealValue);
}
void IRGenDebugInfo::emitArgVariableDeclaration(IRBuilder& Builder,
llvm::Value *Storage,
DebugTypeInfo Ty,
SILDebugScope *DS,
StringRef Name,
unsigned ArgNo,
IndirectionKind Indirection,
ArtificialKind IsArtificial) {
assert(ArgNo > 0);
if (Name == IGM.Context.Id_self.str())
emitVariableDeclaration(Builder, Storage, Ty, DS, Name,
llvm::dwarf::DW_TAG_arg_variable, ArgNo,
DirectValue, ArtificialValue);
else
emitVariableDeclaration(Builder, Storage, Ty, DS, Name,
llvm::dwarf::DW_TAG_arg_variable, ArgNo,
Indirection, IsArtificial);
}
/// Return the DIFile that is the ancestor of Scope.
llvm::DIFile IRGenDebugInfo::getFile(llvm::DIDescriptor Scope) {
while (!Scope.isFile()) {
switch (Scope.getTag()) {
case llvm::dwarf::DW_TAG_lexical_block:
Scope = llvm::DILexicalBlock(Scope).getContext();
break;
case llvm::dwarf::DW_TAG_subprogram:
Scope = llvm::DISubprogram(Scope).getContext().resolve(DIRefMap);
break;
default:
return MainFile;
}
if (Scope.Verify())
return MainFile;
}
llvm::DIFile File(Scope);
assert(File.Verify());
return File;
}
void IRGenDebugInfo::emitVariableDeclaration(IRBuilder& Builder,
llvm::Value *Storage,
DebugTypeInfo Ty,
SILDebugScope *DS,
StringRef Name,
unsigned Tag,
unsigned ArgNo,
IndirectionKind Indirection,
ArtificialKind Artificial) {
// There are variables without storage, such as "struct { func foo() {} }".
// Emit them as constant 0.
if (isa<llvm::UndefValue>(Storage))
Storage = llvm::ConstantInt::get(llvm::Type::getInt64Ty(M.getContext()), 0);
// FIXME: enable this assertion.
//assert(DS);
llvm::DIDescriptor Scope = getOrCreateScope(DS);
Location Loc = getLoc(SM, Ty.getDecl());
// If this is an argument, attach it to the current function scope.
if (ArgNo > 0) {
while (Scope.isLexicalBlock())
Scope = llvm::DILexicalBlock(Scope).getContext();
}
assert(Scope.Verify() && Scope.isScope());
if (!(Scope.Verify() && Scope.isScope()))
return;
llvm::DIFile Unit = getFile(Scope);
// FIXME: this should be the scope of the type's declaration.
llvm::DIType DTy = getOrCreateType(Ty, TheCU);
// If there is no debug info for this type then do not emit debug info
// for this variable.
assert(DTy);
if (!DTy)
return;
unsigned Line = Loc.Line;
unsigned Flags = 0;
if (Artificial)
Flags |= llvm::DIDescriptor::FlagArtificial;
// Create the descriptor for the variable.
llvm::DIVariable Descriptor;
if (Indirection) {
// Classes are always passed by reference.
llvm::Type *Int64Ty = llvm::Type::getInt64Ty(M.getContext());
SmallVector<llvm::Value *, 1> Addr;
Addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIBuilder::OpDeref));
assert(Flags == 0 && "Complex variables cannot have flags");
Descriptor = DBuilder.createComplexVariable(Tag, Scope, Name,
Unit, Line, DTy, Addr, ArgNo);
} else {
Descriptor = DBuilder.createLocalVariable(Tag, Scope, Name,
Unit, Line, DTy,
Opts.OptLevel > 0, Flags, ArgNo);
}
// Insert a debug intrinsic into the current block.
auto BB = Builder.GetInsertBlock();
auto Call = isa<llvm::AllocaInst>(Storage)
? DBuilder.insertDeclare(Storage, Descriptor, BB)
: DBuilder.insertDbgValueIntrinsic(Storage, 0, Descriptor, BB);
Call->setDebugLoc(llvm::DebugLoc::get(Line, Loc.Col, Scope));
}
void IRGenDebugInfo::emitGlobalVariableDeclaration(llvm::GlobalValue *Var,
StringRef Name,
StringRef LinkageName,
DebugTypeInfo DebugType,
Optional<SILLocation> Loc) {
Location L = getLocation(SM, Loc).Loc;
// Global variables in the top level compilation unit are emitted as
// local static variables of SWIFT_ENTRY_POINT_FUNCTION so they
// won't get confused with addressors.
auto Unit = getOrCreateFile(L.Filename);
llvm::DIScope Context = IsLibrary ? Unit : EntryPointFn;
DBuilder.createStaticVariable(Context, Name, LinkageName, Unit,
L.Line, getOrCreateType(DebugType, Context),
Var->hasInternalLinkage(), Var, nullptr);
}
/// Return the mangled name of any nominal type, including the global
/// _Tt prefix, which marks the Swift namespace for types in DWARF.
StringRef IRGenDebugInfo::getMangledName(DebugTypeInfo DTI) {
llvm::SmallString<160> Buffer;
{
llvm::raw_svector_ostream S(Buffer);
Mangle::Mangler M(S, /* DWARF */ true);
M.mangleTypeForDebugger(DTI.getType(), DTI.getDeclContext());
}
assert(!Buffer.empty() && "mangled name came back empty");
return BumpAllocatedString(Buffer);
}
/// Create a member of a struct, class, tuple, or enum.
llvm::DIDerivedType IRGenDebugInfo::createMemberType(DebugTypeInfo DTI,
StringRef Name,
unsigned &OffsetInBits,
llvm::DIDescriptor Scope,
llvm::DIFile File,
unsigned Flags) {
unsigned SizeOfByte = CI.getTargetInfo().getCharWidth();
auto Ty = getOrCreateType(DTI, Scope);
auto DTy = DBuilder.createMemberType(Scope, Name, File, 0,
SizeOfByte*DTI.size.getValue(),
SizeOfByte*DTI.align.getValue(),
OffsetInBits, Flags, Ty);
OffsetInBits += Ty.getSizeInBits();
OffsetInBits = llvm::RoundUpToAlignment(OffsetInBits,
SizeOfByte*DTI.align.getValue());
return DTy;
}
/// Return an array with the DITypes for each of a tuple's elements.
llvm::DIArray IRGenDebugInfo::getTupleElements(TupleType *TupleTy,
llvm::DIDescriptor Scope,
llvm::DIFile File,
unsigned Flags,
DeclContext *DeclContext) {
SmallVector<llvm::Value *, 16> Elements;
unsigned OffsetInBits = 0;
for (auto ElemTy : TupleTy->getElementTypes()) {
DebugTypeInfo DTI(ElemTy, IGM.getTypeInfoForUnlowered(ElemTy), DeclContext);
Elements.push_back(createMemberType(DTI, StringRef(), OffsetInBits,
Scope, File, Flags));
}
return DBuilder.getOrCreateArray(Elements);
}
/// Return an array with the DITypes for each of a struct's elements.
llvm::DIArray IRGenDebugInfo::getStructMembers(NominalTypeDecl *D,
llvm::DIDescriptor Scope,
llvm::DIFile File,
unsigned Flags) {
SmallVector<llvm::Value *, 16> Elements;
unsigned OffsetInBits = 0;
for (auto Decl : D->getMembers())
if (VarDecl *VD = dyn_cast<VarDecl>(Decl))
if (VD->hasStorage()) {
auto Ty = VD->getType()->getCanonicalType();
DebugTypeInfo DTI(VD, IGM.getTypeInfoForUnlowered(Ty));
Elements.push_back(createMemberType(DTI, VD->getName().str(),
OffsetInBits, Scope, File, Flags));
}
return DBuilder.getOrCreateArray(Elements);
}
/// Create a temporary forward declaration for a struct and add it to
/// the type cache so we can safely build recursive types.
llvm::DICompositeType
IRGenDebugInfo::createStructType(DebugTypeInfo DbgTy,
NominalTypeDecl *Decl,
StringRef Name,
llvm::DIDescriptor Scope,
llvm::DIFile File, unsigned Line,
unsigned SizeInBits, unsigned AlignInBits,
unsigned Flags,
llvm::DIType DerivedFrom,
unsigned RuntimeLang) {
auto FwdDecl = DBuilder.createForwardDecl
(llvm::dwarf::DW_TAG_structure_type,
Name, Scope, File, Line, DW_LANG_Swift, SizeInBits, AlignInBits);
DITypeCache[DbgTy.getHash()] = llvm::WeakVH(FwdDecl);
auto DTy = DBuilder.createStructType
(Scope, Name, File, Line, SizeInBits, AlignInBits, Flags, DerivedFrom,
getStructMembers(Decl, Scope, File, Flags), RuntimeLang);
FwdDecl->replaceAllUsesWith(DTy);
return DTy;
}
/// Return an array with the DITypes for each of an enum's elements.
llvm::DIArray IRGenDebugInfo::
getEnumElements(DebugTypeInfo DbgTy,
EnumDecl *D, llvm::DIDescriptor Scope, llvm::DIFile File,
unsigned Flags) {
SmallVector<llvm::Value *, 16> Elements;
for (auto ElemDecl : D->getAllElements()) {
// FIXME <rdar://problem/14845818> Support enums.
// Swift Enums can be both like DWARF enums and DWARF unions.
// We currently cannot represent the enum-like subset of enums.
if (ElemDecl->hasType()) {
auto CanTy = ElemDecl->getType()->getCanonicalType();
// Use Decl as DeclContext.
DebugTypeInfo DTI(ElemDecl, DbgTy.size, DbgTy.align);
auto DTy = getOrCreateDesugaredType(CanTy, DTI, Scope);
Elements.push_back(DTy);
}
}
return DBuilder.getOrCreateArray(Elements);
}
/// Create a temporary forward declaration for an enum and add it to
/// the type cache so we can safely build recursive types.
llvm::DICompositeType
IRGenDebugInfo::createEnumType(DebugTypeInfo DbgTy,
EnumDecl *Decl,
StringRef Name,
llvm::DIDescriptor Scope,
llvm::DIFile File, unsigned Line,
unsigned Flags) {
unsigned SizeOfByte = CI.getTargetInfo().getCharWidth();
unsigned SizeInBits = DbgTy.size.getValue() * SizeOfByte;
unsigned AlignInBits = DbgTy.align.getValue() * SizeOfByte;
// FIXME: Is DW_TAG_union_type the right thing here?
auto FwdDecl = DBuilder.createForwardDecl
(llvm::dwarf::DW_TAG_union_type,
Name, Scope, File, Line, dwarf::DW_LANG_Swift, SizeInBits, AlignInBits);
DITypeCache[DbgTy.getHash()] = llvm::WeakVH(FwdDecl);
auto DTy =
DBuilder.createUnionType(Scope, Name, File, Line,
SizeInBits, AlignInBits, Flags,
getEnumElements(DbgTy, Decl, Scope, File, Flags),
dwarf::DW_LANG_Swift);
FwdDecl->replaceAllUsesWith(DTy);
return DTy;
}
/// Return a DIType for Ty reusing any DeclContext found in DbgTy.
llvm::DIType IRGenDebugInfo::getOrCreateDesugaredType(Type Ty,
DebugTypeInfo DbgTy,
llvm::DIDescriptor Scope)
{
DebugTypeInfo DTI(Ty, DbgTy.size, DbgTy.align, DbgTy.getDeclContext());
return getOrCreateType(DTI, Scope);
}
uint64_t IRGenDebugInfo::getSizeOfBasicType(DebugTypeInfo DbgTy) {
uint64_t SizeOfByte = CI.getTargetInfo().getCharWidth();
uint64_t BitWidth = DbgTy.size.getValue() * SizeOfByte;
llvm::Type *StorageType = DbgTy.StorageType
? DbgTy.StorageType
: IGM.DataLayout.getSmallestLegalIntType(IGM.getLLVMContext(), BitWidth);
if (StorageType)
return IGM.DataLayout.getTypeSizeInBits(StorageType);
// This type is too large to fit in a register.
assert(BitWidth > IGM.DataLayout.getLargestLegalIntTypeSize());
return BitWidth;
}
/// Construct a DIType from a DebugTypeInfo object.
///
/// At this point we do not plan to emit full DWARF for all swift
/// types, the goal is to emit only the name and provenance of the
/// type, where possible. A can import the type definition directly
/// from the module/framework/source file the type is specified in.
/// For this reason we emit the fully qualified (=mangled) name for
/// each type whenever possible.
///
/// The ultimate goal is to emit something like a
/// DW_TAG_APPLE_ast_ref_type (an external reference) instead of a
/// local reference to the type.
llvm::DIType IRGenDebugInfo::createType(DebugTypeInfo DbgTy,
llvm::DIDescriptor Scope,
llvm::DIFile File) {
StringRef Name;
// FIXME: For SizeInBits, clang uses the actual size of the type on
// the target machine instead of the storage size that is alloca'd
// in the LLVM IR. For all types that are boxed in a struct, we are
// emitting the storage size of the struct, but it may be necessary
// to emit the (target!) size of the underlying basic type.
uint64_t SizeOfByte = CI.getTargetInfo().getCharWidth();
uint64_t SizeInBits = DbgTy.size.getValue() * SizeOfByte;
uint64_t AlignInBits = DbgTy.align.getValue() * SizeOfByte;
unsigned Encoding = 0;
unsigned Flags = 0;
TypeBase* BaseTy = DbgTy.getType();
if (!BaseTy) {
DEBUG(llvm::dbgs() << "Type without TypeBase: "; DbgTy.getType()->dump();
llvm::dbgs() << "\n");
Name = "<null>";
return DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
Name, Scope, File, /*Line*/ 0,
DW_LANG_Swift, SizeInBits, AlignInBits);
}
// Here goes!
switch (BaseTy->getKind()) {
case TypeKind::BuiltinInteger: {
auto IntegerTy = BaseTy->castTo<BuiltinIntegerType>();
if (IntegerTy->isFixedWidth()) {
llvm::SmallString<24> buf("Builtin.Int");
llvm::raw_svector_ostream s(buf);
s << IntegerTy->getFixedWidth();
Name = BumpAllocatedString(s.str());
} else if (IntegerTy->getWidth().isPointerWidth()) {
Name = "Builtin.Word";
} else {
llvm_unreachable("impossible width value");
}
Encoding = llvm::dwarf::DW_ATE_unsigned;
SizeInBits = getSizeOfBasicType(DbgTy);
break;
}
case TypeKind::BuiltinFloat: {
auto FloatTy = BaseTy->castTo<BuiltinFloatType>();
// Assuming that the bitwidth and FloatTy->getFPKind() are identical.
SizeInBits = FloatTy->getBitWidth();
llvm::SmallString<24> buf("Builtin.Float");
llvm::raw_svector_ostream s(buf);
s << SizeInBits;
Name = BumpAllocatedString(s.str());
Encoding = llvm::dwarf::DW_ATE_float;
break;
}
case TypeKind::BuiltinObjCPointer: {
// The builtin opaque Objective-C pointer type. Useful for pushing
// an Objective-C type through swift.
auto IdTy = DBuilder.
createStructType(Scope, "objc_object", File, 0, 0, 0, 0,
llvm::DIType(), llvm::DIArray(), DW_LANG_ObjC);
return DBuilder.createPointerType(IdTy, SizeInBits, AlignInBits);
}
case TypeKind::BuiltinObjectPointer: {
Name = getMangledName(DbgTy);
auto PTy = DBuilder.createPointerType(llvm::DIType(),
SizeInBits, AlignInBits, Name);
return DBuilder.createObjectPointerType(PTy);
}
case TypeKind::BuiltinRawPointer:
Name = getMangledName(DbgTy);
return DBuilder.createPointerType(llvm::DIType(),
SizeInBits, AlignInBits, Name);
// Even builtin swift types usually come boxed in a struct.
case TypeKind::Struct: {
Name = getMangledName(DbgTy);
auto StructTy = BaseTy->castTo<StructType>();
if (auto Decl = StructTy->getDecl()) {
Location L = getLoc(SM, Decl);
return createStructType(DbgTy, Decl, Name, Scope,
getOrCreateFile(L.Filename), L.Line,
SizeInBits, AlignInBits, Flags,
llvm::DIType(), // DerivedFrom
DW_LANG_Swift);
}
DEBUG(llvm::dbgs() << "Struct without Decl: "; DbgTy.getType()->dump();
llvm::dbgs() << "\n");
break;
}
case TypeKind::Class: {
// Classes are represented as DW_TAG_structure_type. This way the
// DW_AT_APPLE_runtime_class( DW_LANG_Swift ) attribute can be
// used to differentiate them from C++ and ObjC classes.
Name = getMangledName(DbgTy);
auto ClassTy = BaseTy->castTo<ClassType>();
if (auto *Decl = ClassTy->getDecl()) {
Location L = getLoc(SM, Decl);
auto RuntimeLang = Decl->isObjC() ? DW_LANG_ObjC : DW_LANG_Swift;
if (auto *ClangDecl = Decl->getClangDecl()) {
auto ClangSrcLoc = ClangDecl->getLocStart();
clang::SourceManager &ClangSM =
CI.getClangASTContext().getSourceManager();
L.Line = ClangSM.getPresumedLineNumber(ClangSrcLoc);
L.Filename = ClangSM.getBufferName(ClangSrcLoc);
// Use "ObjectiveC" as default for implicit decls. FIXME: Do
// something more clever based on the decl's mangled name.
StringRef ModuleName = "ObjectiveC";
if (auto *OwningModule = ClangDecl->getOwningModule())
ModuleName = OwningModule->getTopLevelModuleName();
else
assert(ClangDecl->isImplicit() &&
"explicit clang decl without an owning module");
auto ModuleFile = getOrCreateFile(L.Filename);
// This placeholder gets RAUW'd by finalize().
Scope =getOrCreateNamespace(ModuleFile, ModuleName, ModuleFile, L.Line);
}
return createStructType(DbgTy, Decl, Name, Scope,
getOrCreateFile(L.Filename), L.Line,
SizeInBits, AlignInBits, Flags,
llvm::DIType(), // DerivedFrom
RuntimeLang);
}
DEBUG(llvm::dbgs() << "Class without Decl: "; DbgTy.getType()->dump();
llvm::dbgs() << "\n");
break;
}
case TypeKind::Protocol: {
Name = getMangledName(DbgTy);
auto ProtocolTy = BaseTy->castTo<ProtocolType>();
if (auto Decl = ProtocolTy->getDecl()) {
// FIXME: (LLVM branch) Should be DW_TAG_interface_type
Location L = getLoc(SM, Decl);
return createStructType(DbgTy, Decl, Name, Scope,
getOrCreateFile(L.Filename), L.Line,
SizeInBits, AlignInBits, Flags,
llvm::DIType(), // DerivedFrom
DW_LANG_Swift);
}
break;
}
case TypeKind::ProtocolComposition: {
Name = getMangledName(DbgTy);
Location L = getLoc(SM, DbgTy.getDecl());
auto File = getOrCreateFile(L.Filename);
// FIXME: emit types
//auto ProtocolCompositionTy = BaseTy->castTo<ProtocolCompositionType>();
return DBuilder.
createStructType(Scope, Name, File, L.Line,
SizeInBits, AlignInBits, Flags,
llvm::DIType(), // DerivedFrom
llvm::DIArray(),
DW_LANG_Swift);
}
case TypeKind::UnboundGeneric: {
Name = getMangledName(DbgTy);
auto UnboundTy = BaseTy->castTo<UnboundGenericType>();
if (auto Decl = UnboundTy->getDecl()) {
Location L = getLoc(SM, Decl);
return DBuilder.
createStructType(Scope, Name,
getOrCreateFile(L.Filename), L.Line,
SizeInBits, AlignInBits, Flags,
llvm::DIType(), // DerivedFrom
llvm::DIArray(),
DW_LANG_Swift);
}
DEBUG(llvm::dbgs() << "Unbound generic without Decl: ";
DbgTy.getType()->dump(); llvm::dbgs() << "\n");
break;
}
case TypeKind::BoundGenericStruct: {
Name = getMangledName(DbgTy);
auto StructTy = BaseTy->castTo<BoundGenericStructType>();
if (auto Decl = StructTy->getDecl()) {
Location L = getLoc(SM, Decl);
return createStructType(DbgTy, Decl, Name, Scope,
getOrCreateFile(L.Filename), L.Line,
SizeInBits, AlignInBits, Flags,
llvm::DIType(), // DerivedFrom
DW_LANG_Swift);
}
DEBUG(llvm::dbgs() << "Bound Generic struct without Decl: ";
DbgTy.getType()->dump(); llvm::dbgs() << "\n");
break;
}
case TypeKind::BoundGenericClass: {
Name = getMangledName(DbgTy);
auto ClassTy = BaseTy->castTo<BoundGenericClassType>();
if (auto Decl = ClassTy->getDecl()) {
Location L = getLoc(SM, Decl);
auto RuntimeLang = Decl->isObjC()? DW_LANG_ObjC : DW_LANG_Swift;
return createStructType(DbgTy, Decl, Name, Scope,
getOrCreateFile(L.Filename), L.Line,
SizeInBits, AlignInBits, Flags,
llvm::DIType(), // DerivedFrom
RuntimeLang);
}
DEBUG(llvm::dbgs() << "Bound Generic class without Decl: ";
DbgTy.getType()->dump(); llvm::dbgs() << "\n");
break;
}
case TypeKind::Tuple: {
Name = getMangledName(DbgTy);
auto TupleTy = BaseTy->castTo<TupleType>();
auto Decl = DbgTy.getDecl();
Location L = getLoc(SM, Decl);
auto File = getOrCreateFile(L.Filename);
// Tuples are also represented as structs.
return DBuilder.
createStructType(Scope, Name,
File, L.Line,
SizeInBits, AlignInBits, Flags,
llvm::DIType(), // DerivedFrom
getTupleElements(TupleTy, Scope, File, Flags,
DbgTy.getDeclContext()),
DW_LANG_Swift);
}
case TypeKind::InOut: {
// This is an inout type.
auto ObjectTy = BaseTy->castTo<InOutType>()->getObjectType();
auto DT = getOrCreateDesugaredType(ObjectTy, DbgTy, Scope);
return DBuilder.createReferenceType(llvm::dwarf::DW_TAG_reference_type, DT);
}
case TypeKind::Archetype: {
auto Archetype = BaseTy->castTo<ArchetypeType>();
Name = getMangledName(DbgTy);
Location L = getLoc(SM, Archetype->getAssocType());
auto Superclass = Archetype->getSuperclass();
auto DerivedFrom = Superclass.isNull() ? llvm::DIType() :
getOrCreateDesugaredType(Superclass, DbgTy, Scope);
auto DITy = DBuilder.createStructType(Scope, Name, File, L.Line,
SizeInBits, AlignInBits, Flags,
DerivedFrom, llvm::DIArray(),
DW_LANG_Swift);
// Emit the protocols the archetypes conform to.
SmallVector<llvm::Value *, 4> Protocols;
for (auto ProtocolDecl : Archetype->getConformsTo()) {
auto PTy = IGM.SILMod->Types.getLoweredType(ProtocolDecl->getType())
.getSwiftRValueType();
auto PDbgTy = DebugTypeInfo(ProtocolDecl, IGM.getTypeInfoForLowered(PTy));
auto PDITy = getOrCreateType(PDbgTy, Scope);
Protocols.push_back(DBuilder.createInheritance(DITy, PDITy, 0, Flags));
}
DITy.setTypeArray(DBuilder.getOrCreateArray(Protocols));
return DITy;
}
case TypeKind::ExistentialMetatype:
case TypeKind::Metatype: {
// Metatypes are (mostly) singleton type descriptors, often without storage.
auto Metatype = BaseTy->castTo<AnyMetatypeType>();
auto Ty = Metatype->getInstanceType();
// The type this metatype is describing.
// FIXME: Reusing the size and alignment of the metatype for the type is wrong.
auto DITy = getOrCreateDesugaredType(Ty, DbgTy, Scope);
return DBuilder.createQualifiedType(DW_TAG_meta_type, DITy);
}
case TypeKind::SILFunction:
case TypeKind::Function:
case TypeKind::PolymorphicFunction:
case TypeKind::GenericFunction:
{
CanSILFunctionType FunctionTy;
if (auto SILFnTy = dyn_cast<SILFunctionType>(BaseTy))
FunctionTy = CanSILFunctionType(SILFnTy);
// FIXME: Handling of generic parameters in SIL type lowering is in flux.
// DebugInfo doesn't appear to care about the generic context, so just
// throw it away before lowering.
else if (isa<GenericFunctionType>(BaseTy) ||
isa<PolymorphicFunctionType>(BaseTy)) {
auto fTy = cast<AnyFunctionType>(BaseTy);
auto nongenericTy = FunctionType::get(fTy->getInput(),
fTy->getResult(),
fTy->getExtInfo());
FunctionTy = IGM.SILMod->Types.getLoweredType(nongenericTy)
.castTo<SILFunctionType>();
} else
FunctionTy = IGM.SILMod->Types.getLoweredType(BaseTy)
.castTo<SILFunctionType>();
auto Params=createParameterTypes(FunctionTy, Scope, DbgTy.getDeclContext());
auto FnTy = DBuilder.createSubroutineType(MainFile, Params);
return DBuilder.createPointerType(FnTy, SizeInBits, AlignInBits);
}
case TypeKind::Enum:
{
Name = getMangledName(DbgTy);
auto EnumTy = BaseTy->castTo<EnumType>();
if (auto Decl = EnumTy->getDecl()) {
Location L = getLoc(SM, Decl);
return createEnumType(DbgTy, Decl, Name, Scope,
getOrCreateFile(L.Filename), L.Line, Flags);
}
DEBUG(llvm::dbgs() << "Enum type without Decl: ";
DbgTy.getType()->dump(); llvm::dbgs() << "\n");
break;
}
case TypeKind::BoundGenericEnum:
{
Name = getMangledName(DbgTy);
auto EnumTy = BaseTy->castTo<BoundGenericEnumType>();
if (auto Decl = EnumTy->getDecl()) {
Location L = getLoc(SM, Decl);
return createEnumType(DbgTy, Decl, Name, Scope,
getOrCreateFile(L.Filename), L.Line, Flags);
}
DEBUG(llvm::dbgs() << "Bound generic enum type without Decl: ";
DbgTy.getType()->dump(); llvm::dbgs() << "\n");
break;
}
case TypeKind::BuiltinVector: {
Name = getMangledName(DbgTy);
(void)Name; // FIXME emit the name somewhere.
auto BuiltinVectorTy = BaseTy->castTo<BuiltinVectorType>();
DebugTypeInfo DTI(BuiltinVectorTy->getElementType(),
DbgTy.size, DbgTy.align, DbgTy.getDeclContext());
auto Subscripts = llvm::DIArray();
return DBuilder.createVectorType(BuiltinVectorTy->getNumElements(),
AlignInBits,
getOrCreateType(DTI, File),
Subscripts);
}
// Reference storage types.
case TypeKind::UnownedStorage:
case TypeKind::WeakStorage: {
Name = getMangledName(DbgTy);
auto ReferenceTy = cast<ReferenceStorageType>(BaseTy);
auto CanTy = ReferenceTy->getReferentType();
Location L = getLoc(SM, DbgTy.getDecl());
auto File = getOrCreateFile(L.Filename);
return DBuilder.createTypedef(getOrCreateDesugaredType(CanTy, DbgTy, Scope),
Name, File, L.Line, File);
}
// Sugared types.
case TypeKind::NameAlias: {
Name = getMangledName(DbgTy);
auto NameAliasTy = cast<NameAliasType>(BaseTy);
if (auto Decl = NameAliasTy->getDecl()) {
Location L = getLoc(SM, Decl);
auto AliasedTy = Decl->getUnderlyingType();
auto File = getOrCreateFile(L.Filename);
// For NameAlias types, the DeclContext for the aliasED type is
// in the decl of the alias type.
DebugTypeInfo DTI(AliasedTy,
DbgTy.size, DbgTy.align, DbgTy.getDeclContext());
return DBuilder.createTypedef(getOrCreateType(DTI, Scope),
Name, File, L.Line, File);
}
DEBUG(llvm::dbgs() << "Name alias without Decl: ";
DbgTy.getType()->dump(); llvm::dbgs() << "\n");
break;
}
case TypeKind::Substituted: {
Name = getMangledName(DbgTy);
auto SubstitutedTy = cast<SubstitutedType>(BaseTy);
auto OrigTy = SubstitutedTy->getReplacementType();
Location L = getLoc(SM, DbgTy.getDecl());
auto File = getOrCreateFile(L.Filename);
return DBuilder.createTypedef(getOrCreateDesugaredType(OrigTy,DbgTy,Scope),
Name, File, L.Line, File);
}
case TypeKind::Paren: {
Name = getMangledName(DbgTy);
auto ParenTy = cast<ParenType>(BaseTy);
auto Ty = ParenTy->getUnderlyingType();
Location L = getLoc(SM, DbgTy.getDecl());
auto File = getOrCreateFile(L.Filename);
return DBuilder.createTypedef(getOrCreateDesugaredType(Ty, DbgTy, Scope),
Name, File, L.Line, File);
}
// SyntaxSugarType derivations.
case TypeKind::ArraySlice:
case TypeKind::Optional:
case TypeKind::UncheckedOptional: {
auto SyntaxSugarTy = cast<SyntaxSugarType>(BaseTy);
auto CanTy = SyntaxSugarTy->getDesugaredType();
return getOrCreateDesugaredType(CanTy, DbgTy, Scope);
}
case TypeKind::GenericTypeParam: {
auto ParamTy = cast<GenericTypeParamType>(BaseTy);
// FIXME: Provide a more meaningful debug type.
return DBuilder.createUnspecifiedType(ParamTy->getName().str());
}
case TypeKind::DependentMember: {
auto MemberTy = cast<DependentMemberType>(BaseTy);
// FIXME: Provide a more meaningful debug type.
return DBuilder.createUnspecifiedType(MemberTy->getName().str());
}
case TypeKind::Array:
case TypeKind::AssociatedType:
case TypeKind::Error:
case TypeKind::LValue:
case TypeKind::Module:
case TypeKind::DynamicSelf:
case TypeKind::TypeVariable:
DEBUG(llvm::errs() << "Unhandled type: "; DbgTy.getType()->dump();
llvm::errs() << "\n");
Name = "<unknown>";
}
return DBuilder.createBasicType(Name, SizeInBits, AlignInBits, Encoding);
}
/// Get the DIType corresponding to this DebugTypeInfo from the cache,
/// or build a fresh DIType otherwise. There is the underlying
/// assumption that no two types that share the same canonical type
/// can have different storage size or alignment.
llvm::DIType IRGenDebugInfo::getOrCreateType(DebugTypeInfo DbgTy,
llvm::DIDescriptor Scope) {
// Is this an empty type?
if (DbgTy.isNull())
// We use the empty type as an index into DenseMap.
return createType(DbgTy, Scope, getFile(Scope));
// Look in the cache first.
auto CachedType = DITypeCache.find(DbgTy.getHash());
if (CachedType != DITypeCache.end()) {
// Verify that the information still exists.
if (llvm::Value *Val = CachedType->second) {
auto DITy = llvm::DIType(cast<llvm::MDNode>(Val));
if (DITy.Verify())
return DITy;
}
}
llvm::DIType DITy = createType(DbgTy, Scope, getFile(Scope));
DITy.Verify();
auto CompTy = llvm::getDICompositeType(DITy);
DIRefMap.insert({ CompTy.getIdentifier(), CompTy });
DITypeCache[DbgTy.getHash()] = llvm::WeakVH(DITy);
return DITy;
}
void IRGenDebugInfo::finalize() {
assert(LocationStack.empty() && "Mismatch of pushLoc() and popLoc().");
// Create an import declaration for the module defined by current
// compilation unit so we can record the module name in DWARF.
llvm::DINameSpace Namespace(getOrCreateNamespace(MainFile, Opts.ModuleName,
MainFile, 1));
std::string Mangled("_TF");
llvm::raw_string_ostream MS(Mangled);
if (Opts.ModuleName == IGM.Context.StdlibModuleName.str())
MS << "S";
else
mangleIdent(MS, Opts.ModuleName);
createImportedModule(Opts.ModuleName, MS.str(), Namespace);
// The default for a function is to be in the file-level scope.
for (auto FVH: Functions) {
auto F = llvm::DISubprogram(cast<llvm::MDNode>(FVH.second));
auto Scope = F.getContext().resolve(DIRefMap);
if (Scope.isType() && llvm::DIType(Scope).isForwardDecl())
Scope->replaceAllUsesWith(MainFile);
}
// Finalize the DIBuilder.
DBuilder.finalize();
}
Reference in New Issue View Git Blame Copy Permalink