mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
499 lines
17 KiB
C++
499 lines
17 KiB
C++
//===--- IRGenOptions.h - Swift Language IR Generation Options --*- C++ -*-===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2017 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines the options which control the generation of IR for
|
|
// swift files.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef SWIFT_AST_IRGENOPTIONS_H
|
|
#define SWIFT_AST_IRGENOPTIONS_H
|
|
|
|
#include "swift/AST/LinkLibrary.h"
|
|
#include "swift/Basic/PathRemapper.h"
|
|
#include "swift/Basic/Sanitizers.h"
|
|
#include "swift/Basic/OptionSet.h"
|
|
#include "swift/Basic/OptimizationMode.h"
|
|
#include "swift/Config.h"
|
|
#include "clang/Basic/PointerAuthOptions.h"
|
|
// FIXME: This include is just for llvm::SanitizerCoverageOptions. We should
|
|
// split the header upstream so we don't include so much.
|
|
#include "llvm/Transforms/Instrumentation.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
#include "llvm/Support/VersionTuple.h"
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
namespace swift {
|
|
|
|
enum class IRGenOutputKind : unsigned {
|
|
/// Just generate an LLVM module and return it.
|
|
Module,
|
|
|
|
/// Generate an LLVM module and write it out as LLVM assembly.
|
|
LLVMAssemblyBeforeOptimization,
|
|
|
|
/// Generate an LLVM module and write it out as LLVM assembly.
|
|
LLVMAssemblyAfterOptimization,
|
|
|
|
/// Generate an LLVM module and write it out as LLVM bitcode.
|
|
LLVMBitcode,
|
|
|
|
/// Generate an LLVM module and compile it to assembly.
|
|
NativeAssembly,
|
|
|
|
/// Generate an LLVM module, compile it, and assemble into an object file.
|
|
ObjectFile
|
|
};
|
|
|
|
enum class IRGenDebugInfoLevel : unsigned {
|
|
None, ///< No debug info.
|
|
LineTables, ///< Line tables only.
|
|
ASTTypes, ///< Line tables + AST type references.
|
|
DwarfTypes, ///< Line tables + AST type references + DWARF types.
|
|
Normal = ASTTypes ///< The setting LLDB prefers.
|
|
};
|
|
|
|
enum class IRGenDebugInfoFormat : unsigned {
|
|
None,
|
|
DWARF,
|
|
CodeView
|
|
};
|
|
|
|
enum class IRGenLLVMLTOKind : unsigned {
|
|
None,
|
|
Thin,
|
|
Full,
|
|
};
|
|
|
|
enum class IRGenEmbedMode : unsigned {
|
|
None,
|
|
EmbedMarker,
|
|
EmbedBitcode
|
|
};
|
|
|
|
enum class SwiftAsyncFramePointerKind : unsigned {
|
|
Auto, // Choose Swift async extended frame info based on deployment target.
|
|
Always, // Unconditionally emit Swift async extended frame info.
|
|
Never, // Don't emit Swift async extended frame info.
|
|
};
|
|
|
|
using clang::PointerAuthSchema;
|
|
|
|
struct PointerAuthOptions : clang::PointerAuthOptions {
|
|
/// Native opaque function types, both thin and thick.
|
|
/// Never address-sensitive.
|
|
PointerAuthSchema SwiftFunctionPointers;
|
|
|
|
/// Swift key path helpers.
|
|
PointerAuthSchema KeyPaths;
|
|
|
|
/// Swift value witness functions.
|
|
PointerAuthSchema ValueWitnesses;
|
|
|
|
/// Swift protocol witness functions.
|
|
PointerAuthSchema ProtocolWitnesses;
|
|
|
|
/// Swift protocol witness table associated type metadata access functions.
|
|
PointerAuthSchema ProtocolAssociatedTypeAccessFunctions;
|
|
|
|
/// Swift protocol witness table associated conformance witness table
|
|
/// access functions.
|
|
PointerAuthSchema ProtocolAssociatedTypeWitnessTableAccessFunctions;
|
|
|
|
/// Swift class v-table functions.
|
|
PointerAuthSchema SwiftClassMethods;
|
|
|
|
/// Swift dynamic replacement implementations.
|
|
PointerAuthSchema SwiftDynamicReplacements;
|
|
PointerAuthSchema SwiftDynamicReplacementKeys;
|
|
|
|
/// Swift class v-table functions not signed with an address. This is the
|
|
/// return type of swift_lookUpClassMethod().
|
|
PointerAuthSchema SwiftClassMethodPointers;
|
|
|
|
/// Swift heap metadata destructors.
|
|
PointerAuthSchema HeapDestructors;
|
|
|
|
/// Non-constant function pointers captured in a partial-apply context.
|
|
PointerAuthSchema PartialApplyCapture;
|
|
|
|
/// Type descriptor data pointers.
|
|
PointerAuthSchema TypeDescriptors;
|
|
|
|
/// Type descriptor data pointers when passed as arguments.
|
|
PointerAuthSchema TypeDescriptorsAsArguments;
|
|
|
|
/// Protocol conformance descriptors.
|
|
PointerAuthSchema ProtocolConformanceDescriptors;
|
|
|
|
/// Protocol conformance descriptors when passed as arguments.
|
|
PointerAuthSchema ProtocolConformanceDescriptorsAsArguments;
|
|
|
|
/// Resumption functions from yield-once coroutines.
|
|
PointerAuthSchema YieldOnceResumeFunctions;
|
|
|
|
/// Resumption functions from yield-many coroutines.
|
|
PointerAuthSchema YieldManyResumeFunctions;
|
|
|
|
/// Resilient class stub initializer callbacks.
|
|
PointerAuthSchema ResilientClassStubInitCallbacks;
|
|
|
|
/// Like SwiftFunctionPointers but for use with AsyncFunctionPointer values.
|
|
PointerAuthSchema AsyncSwiftFunctionPointers;
|
|
|
|
/// Like SwiftClassMethods but for use with AsyncFunctionPointer values.
|
|
PointerAuthSchema AsyncSwiftClassMethods;
|
|
|
|
/// Like ProtocolWitnesses but for use with AsyncFunctionPointer values.
|
|
PointerAuthSchema AsyncProtocolWitnesses;
|
|
|
|
/// Like SwiftClassMethodPointers but for use with AsyncFunctionPointer
|
|
/// values.
|
|
PointerAuthSchema AsyncSwiftClassMethodPointers;
|
|
|
|
/// Like SwiftDynamicReplacements but for use with AsyncFunctionPointer
|
|
/// values.
|
|
PointerAuthSchema AsyncSwiftDynamicReplacements;
|
|
|
|
/// Like PartialApplyCapture but for use with AsyncFunctionPointer values.
|
|
PointerAuthSchema AsyncPartialApplyCapture;
|
|
|
|
/// The parent async context stored within a child async context.
|
|
PointerAuthSchema AsyncContextParent;
|
|
|
|
/// The function to call to resume running in the parent context.
|
|
PointerAuthSchema AsyncContextResume;
|
|
|
|
/// The resume function stored in AsyncTask.
|
|
PointerAuthSchema TaskResumeFunction;
|
|
|
|
/// The async context stored in AsyncTask.
|
|
PointerAuthSchema TaskResumeContext;
|
|
|
|
/// The swift async context entry in the extended frame info.
|
|
PointerAuthSchema AsyncContextExtendedFrameEntry;
|
|
};
|
|
|
|
enum class JITDebugArtifact : unsigned {
|
|
None, ///< None
|
|
LLVMIR, ///< LLVM IR
|
|
Object, ///< Object File
|
|
};
|
|
|
|
/// The set of options supported by IR generation.
|
|
class IRGenOptions {
|
|
public:
|
|
std::string ModuleName;
|
|
|
|
/// The compilation directory for the debug info.
|
|
std::string DebugCompilationDir;
|
|
|
|
/// The DWARF version of debug info.
|
|
unsigned DWARFVersion;
|
|
|
|
/// The command line string that is to be stored in the debug info.
|
|
std::string DebugFlags;
|
|
|
|
/// List of -Xcc -D macro definitions.
|
|
std::vector<std::string> ClangDefines;
|
|
|
|
/// The libraries and frameworks specified on the command line.
|
|
SmallVector<LinkLibrary, 4> LinkLibraries;
|
|
|
|
/// The public dependent libraries specified on the command line.
|
|
std::vector<std::string> PublicLinkLibraries;
|
|
|
|
/// If non-empty, the (unmangled) name of a dummy symbol to emit that can be
|
|
/// used to force-load this module.
|
|
std::string ForceLoadSymbolName;
|
|
|
|
/// The kind of compilation we should do.
|
|
IRGenOutputKind OutputKind : 3;
|
|
|
|
/// Should we spend time verifying that the IR we produce is
|
|
/// well-formed?
|
|
unsigned Verify : 1;
|
|
|
|
OptimizationMode OptMode;
|
|
|
|
/// Which sanitizer is turned on.
|
|
OptionSet<SanitizerKind> Sanitizers;
|
|
|
|
/// Which sanitizer(s) have recovery instrumentation enabled.
|
|
OptionSet<SanitizerKind> SanitizersWithRecoveryInstrumentation;
|
|
|
|
/// Whether to enable ODR indicators when building with ASan.
|
|
unsigned SanitizeAddressUseODRIndicator : 1;
|
|
|
|
/// Path prefixes that should be rewritten in debug info.
|
|
PathRemapper DebugPrefixMap;
|
|
|
|
/// Path prefixes that should be rewritten in coverage info.
|
|
PathRemapper CoveragePrefixMap;
|
|
|
|
/// What level of debug info to generate.
|
|
IRGenDebugInfoLevel DebugInfoLevel : 2;
|
|
|
|
/// What type of debug info to generate.
|
|
IRGenDebugInfoFormat DebugInfoFormat : 2;
|
|
|
|
/// Whether to leave DWARF breadcrumbs pointing to imported Clang modules.
|
|
unsigned DisableClangModuleSkeletonCUs : 1;
|
|
|
|
/// Whether we're generating IR for the JIT.
|
|
unsigned UseJIT : 1;
|
|
|
|
/// Whether we should run LLVM optimizations after IRGen.
|
|
unsigned DisableLLVMOptzns : 1;
|
|
|
|
/// Whether we should run swift specific LLVM optimizations after IRGen.
|
|
unsigned DisableSwiftSpecificLLVMOptzns : 1;
|
|
|
|
/// Special codegen for playgrounds.
|
|
unsigned Playground : 1;
|
|
|
|
/// Emit runtime calls to check the end of the lifetime of stack promoted
|
|
/// objects.
|
|
unsigned EmitStackPromotionChecks : 1;
|
|
|
|
/// Emit functions to separate sections.
|
|
unsigned FunctionSections : 1;
|
|
|
|
/// The maximum number of bytes used on a stack frame for stack promotion
|
|
/// (includes alloc_stack allocations).
|
|
unsigned StackPromotionSizeLimit = 1024;
|
|
|
|
/// Emit code to verify that static and runtime type layout are consistent for
|
|
/// the given type names.
|
|
SmallVector<StringRef, 1> VerifyTypeLayoutNames;
|
|
|
|
/// Frameworks that we should not autolink against.
|
|
SmallVector<std::string, 1> DisableAutolinkFrameworks;
|
|
|
|
/// Print the LLVM inline tree at the end of the LLVM pass pipeline.
|
|
unsigned PrintInlineTree : 1;
|
|
|
|
/// Whether we should embed the bitcode file.
|
|
IRGenEmbedMode EmbedMode : 2;
|
|
|
|
IRGenLLVMLTOKind LLVMLTOKind : 2;
|
|
|
|
SwiftAsyncFramePointerKind SwiftAsyncFramePointer : 2;
|
|
|
|
/// Add names to LLVM values.
|
|
unsigned HasValueNamesSetting : 1;
|
|
unsigned ValueNames : 1;
|
|
|
|
/// Emit nominal type field metadata.
|
|
unsigned EnableReflectionMetadata : 1;
|
|
|
|
/// Emit names of struct stored properties and enum cases.
|
|
unsigned EnableReflectionNames : 1;
|
|
|
|
/// Emit mangled names of anonymous context descriptors.
|
|
unsigned EnableAnonymousContextMangledNames : 1;
|
|
|
|
/// Force public linkage for private symbols. Used only by the LLDB
|
|
/// expression evaluator.
|
|
unsigned ForcePublicLinkage : 1;
|
|
|
|
/// Force lazy initialization of class metadata
|
|
/// Used on Windows to avoid cross-module references.
|
|
unsigned LazyInitializeClassMetadata : 1;
|
|
unsigned LazyInitializeProtocolConformances : 1;
|
|
unsigned IndirectAsyncFunctionPointer : 1;
|
|
|
|
/// Normally if the -read-legacy-type-info flag is not specified, we look for
|
|
/// a file named "legacy-<arch>.yaml" in SearchPathOpts.RuntimeLibraryPath.
|
|
/// Passing this flag completely disables this behavior.
|
|
unsigned DisableLegacyTypeInfo : 1;
|
|
|
|
/// Create metadata specializations for generic types at statically known type
|
|
/// arguments.
|
|
unsigned PrespecializeGenericMetadata : 1;
|
|
|
|
/// The path to load legacy type layouts from.
|
|
StringRef ReadLegacyTypeInfoPath;
|
|
|
|
/// Should we try to build incrementally by not emitting an object file if it
|
|
/// has the same IR hash as the module that we are preparing to emit?
|
|
///
|
|
/// This is a debugging option meant to make it easier to perform compile time
|
|
/// measurements on a non-clean build directory.
|
|
unsigned UseIncrementalLLVMCodeGen : 1;
|
|
|
|
/// Enable the use of type layouts for value witness functions and use
|
|
/// vw functions instead of outlined copy/destroy functions.
|
|
unsigned UseTypeLayoutValueHandling : 1;
|
|
|
|
/// Also force structs to be lowered to aligned group TypeLayouts rather than
|
|
/// using TypeInfo entries.
|
|
unsigned ForceStructTypeLayouts : 1;
|
|
|
|
/// Instrument code to generate profiling information.
|
|
unsigned GenerateProfile : 1;
|
|
|
|
/// Enable chaining of dynamic replacements.
|
|
unsigned EnableDynamicReplacementChaining : 1;
|
|
|
|
/// Disable round-trip verification of mangled debug types.
|
|
unsigned DisableRoundTripDebugTypes : 1;
|
|
|
|
/// Whether to disable shadow copies for local variables on the stack. This is
|
|
/// only used for testing.
|
|
unsigned DisableDebuggerShadowCopies : 1;
|
|
|
|
/// Whether to disable using mangled names for accessing concrete type metadata.
|
|
unsigned DisableConcreteTypeMetadataMangledNameAccessors : 1;
|
|
|
|
/// Whether to disable referencing stdlib symbols via mangled names in
|
|
/// reflection mangling.
|
|
unsigned DisableStandardSubstitutionsInReflectionMangling : 1;
|
|
|
|
unsigned EnableGlobalISel : 1;
|
|
|
|
unsigned VirtualFunctionElimination : 1;
|
|
|
|
unsigned WitnessMethodElimination : 1;
|
|
|
|
unsigned ConditionalRuntimeRecords : 1;
|
|
|
|
unsigned InternalizeAtLink : 1;
|
|
|
|
/// The number of threads for multi-threaded code generation.
|
|
unsigned NumThreads = 0;
|
|
|
|
/// Path to the profdata file to be used for PGO, or the empty string.
|
|
std::string UseProfile = "";
|
|
|
|
/// List of backend command-line options for -embed-bitcode.
|
|
std::vector<uint8_t> CmdArgs;
|
|
|
|
/// Which sanitizer coverage is turned on.
|
|
llvm::SanitizerCoverageOptions SanitizeCoverage;
|
|
|
|
/// Pointer authentication.
|
|
PointerAuthOptions PointerAuth;
|
|
|
|
/// The different modes for dumping IRGen type info.
|
|
enum class TypeInfoDumpFilter {
|
|
All,
|
|
Resilient,
|
|
Fragile
|
|
};
|
|
|
|
TypeInfoDumpFilter TypeInfoFilter;
|
|
|
|
/// Pull in runtime compatibility shim libraries by autolinking.
|
|
Optional<llvm::VersionTuple> AutolinkRuntimeCompatibilityLibraryVersion;
|
|
Optional<llvm::VersionTuple> AutolinkRuntimeCompatibilityDynamicReplacementLibraryVersion;
|
|
Optional<llvm::VersionTuple>
|
|
AutolinkRuntimeCompatibilityConcurrencyLibraryVersion;
|
|
|
|
JITDebugArtifact DumpJIT = JITDebugArtifact::None;
|
|
|
|
IRGenOptions()
|
|
: DWARFVersion(2),
|
|
OutputKind(IRGenOutputKind::LLVMAssemblyAfterOptimization),
|
|
Verify(true), OptMode(OptimizationMode::NotSet),
|
|
Sanitizers(OptionSet<SanitizerKind>()),
|
|
SanitizersWithRecoveryInstrumentation(OptionSet<SanitizerKind>()),
|
|
SanitizeAddressUseODRIndicator(false),
|
|
DebugInfoLevel(IRGenDebugInfoLevel::None),
|
|
DebugInfoFormat(IRGenDebugInfoFormat::None),
|
|
DisableClangModuleSkeletonCUs(false), UseJIT(false),
|
|
DisableLLVMOptzns(false), DisableSwiftSpecificLLVMOptzns(false),
|
|
Playground(false),
|
|
EmitStackPromotionChecks(false), FunctionSections(false),
|
|
PrintInlineTree(false), EmbedMode(IRGenEmbedMode::None),
|
|
LLVMLTOKind(IRGenLLVMLTOKind::None),
|
|
SwiftAsyncFramePointer(SwiftAsyncFramePointerKind::Auto),
|
|
HasValueNamesSetting(false),
|
|
ValueNames(false), EnableReflectionMetadata(true),
|
|
EnableReflectionNames(true), EnableAnonymousContextMangledNames(false),
|
|
ForcePublicLinkage(false), LazyInitializeClassMetadata(false),
|
|
LazyInitializeProtocolConformances(false),
|
|
IndirectAsyncFunctionPointer(false), DisableLegacyTypeInfo(false),
|
|
PrespecializeGenericMetadata(false), UseIncrementalLLVMCodeGen(true),
|
|
UseTypeLayoutValueHandling(true), ForceStructTypeLayouts(false),
|
|
GenerateProfile(false), EnableDynamicReplacementChaining(false),
|
|
DisableRoundTripDebugTypes(false), DisableDebuggerShadowCopies(false),
|
|
DisableConcreteTypeMetadataMangledNameAccessors(false),
|
|
DisableStandardSubstitutionsInReflectionMangling(false),
|
|
EnableGlobalISel(false), VirtualFunctionElimination(false),
|
|
WitnessMethodElimination(false), ConditionalRuntimeRecords(false),
|
|
InternalizeAtLink(false),
|
|
CmdArgs(),
|
|
SanitizeCoverage(llvm::SanitizerCoverageOptions()),
|
|
TypeInfoFilter(TypeInfoDumpFilter::All) {}
|
|
|
|
/// Appends to \p os an arbitrary string representing all options which
|
|
/// influence the llvm compilation but are not reflected in the llvm module
|
|
/// itself.
|
|
void writeLLVMCodeGenOptionsTo(llvm::raw_ostream &os) const {
|
|
// We put a letter between each value simply to keep them from running into
|
|
// one another. There might be a vague correspondence between meaning and
|
|
// letter, but don't sweat it.
|
|
os << 'O' << (unsigned)OptMode
|
|
<< 'd' << DisableLLVMOptzns
|
|
<< 'D' << DisableSwiftSpecificLLVMOptzns
|
|
<< 'p' << GenerateProfile
|
|
<< 's' << Sanitizers.toRaw();
|
|
}
|
|
|
|
/// Should LLVM IR value names be emitted and preserved?
|
|
bool shouldProvideValueNames() const {
|
|
// If the command line contains an explicit request about whether to add
|
|
// LLVM value names, honor it. Otherwise, add value names only if the
|
|
// final result is textual LLVM assembly.
|
|
if (HasValueNamesSetting) {
|
|
return ValueNames;
|
|
} else {
|
|
return OutputKind == IRGenOutputKind::LLVMAssemblyBeforeOptimization ||
|
|
OutputKind == IRGenOutputKind::LLVMAssemblyAfterOptimization;
|
|
}
|
|
}
|
|
|
|
bool shouldOptimize() const {
|
|
return OptMode > OptimizationMode::NoOptimization;
|
|
}
|
|
|
|
bool optimizeForSize() const {
|
|
return OptMode == OptimizationMode::ForSize;
|
|
}
|
|
|
|
std::string getDebugFlags(StringRef PrivateDiscriminator) const {
|
|
std::string Flags = DebugFlags;
|
|
if (!PrivateDiscriminator.empty()) {
|
|
if (!Flags.empty())
|
|
Flags += " ";
|
|
Flags += ("-private-discriminator " + PrivateDiscriminator).str();
|
|
}
|
|
return Flags;
|
|
}
|
|
|
|
/// Return a hash code of any components from these options that should
|
|
/// contribute to a Swift Bridging PCH hash.
|
|
llvm::hash_code getPCHHashComponents() const {
|
|
return llvm::hash_value(0);
|
|
}
|
|
|
|
bool hasMultipleIRGenThreads() const { return NumThreads > 1; }
|
|
bool shouldPerformIRGenerationInParallel() const { return NumThreads != 0; }
|
|
bool hasMultipleIGMs() const { return hasMultipleIRGenThreads(); }
|
|
};
|
|
|
|
} // end namespace swift
|
|
|
|
#endif
|