Add module trace information for strict memory safety

Extend the module trace format with a field indicating whether a given
module, or any module it depends on, was compiled with strict memory
safety enabled. This separate output from the compiler can be used as
part of an audit to determine what parts of Swift programs are built
with strict memory safety checking enabled.

Author: DougGregor

include/swift/AST/Decl.h

@@ -726,7 +726,7 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl>, public Swi
     HasAnyUnavailableDuringLoweringValues : 1
   );
 
-  SWIFT_INLINE_BITFIELD(ModuleDecl, TypeDecl, 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+8,
+  SWIFT_INLINE_BITFIELD(ModuleDecl, TypeDecl, 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+8,
     /// If the module is compiled as static library.
     StaticLibrary : 1,
 
@@ -792,7 +792,10 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl>, public Swi
     AllowNonResilientAccess : 1,
 
     /// Whether this module has been built with -package-cmo.
-    SerializePackageEnabled : 1
+    SerializePackageEnabled : 1,
+
+    /// Whether this module has enabled strict memory safety checking.
+    StrictMemorySafety : 1
   );
 
   SWIFT_INLINE_BITFIELD(PrecedenceGroupDecl, Decl, 1+2,

include/swift/AST/Module.h

@@ -830,6 +830,15 @@ class ModuleDecl
     Bits.ModuleDecl.IsConcurrencyChecked = value;
   }
 
+  /// Whether this module has enable strict memory safety checking.
+  bool strictMemorySafety() const {
+    return Bits.ModuleDecl.StrictMemorySafety;
+  }
+
+  void setStrictMemorySafety(bool value = true) {
+    Bits.ModuleDecl.StrictMemorySafety = value;
+  }
+
   bool isObjCNameLookupCachePopulated() const {
     return Bits.ModuleDecl.ObjCNameLookupCachePopulated;
   }

include/swift/Serialization/Validation.h

@@ -149,6 +149,7 @@ class ExtendedValidationInfo {
     unsigned HasCxxInteroperability : 1;
     unsigned AllowNonResilientAccess: 1;
     unsigned SerializePackageEnabled: 1;
+    unsigned StrictMemorySafety: 1;
   } Bits;
 public:
   ExtendedValidationInfo() : Bits() {}
@@ -246,6 +247,13 @@ class ExtendedValidationInfo {
   void setIsConcurrencyChecked(bool val = true) {
     Bits.IsConcurrencyChecked = val;
   }
+  bool strictMemorySafety() const {
+    return Bits.StrictMemorySafety;
+  }
+  void setStrictMemorySafety(bool val = true) {
+    Bits.StrictMemorySafety = val;
+  }
+  
   bool hasCxxInteroperability() const { return Bits.HasCxxInteroperability; }
   void setHasCxxInteroperability(bool val) {
     Bits.HasCxxInteroperability = val;

lib/AST/Module.cpp

@@ -781,6 +781,7 @@ ModuleDecl::ModuleDecl(Identifier name, ASTContext &ctx,
   Bits.ModuleDecl.CXXStdlibKind = 0;
   Bits.ModuleDecl.AllowNonResilientAccess = 0;
   Bits.ModuleDecl.SerializePackageEnabled = 0;
+  Bits.ModuleDecl.StrictMemorySafety = 0;
 
   // Populate the module's files.
   SmallVector<FileUnit *, 2> files;

lib/Frontend/Frontend.cpp

@@ -1497,6 +1497,8 @@ ModuleDecl *CompilerInstance::getMainModule() const {
       MainModule->setAllowNonResilientAccess();
     if (Invocation.getSILOptions().EnableSerializePackage)
       MainModule->setSerializePackageEnabled();
+    if (Invocation.getLangOptions().hasFeature(Feature::WarnUnsafe))
+      MainModule->setStrictMemorySafety(true);
 
     if (!Invocation.getFrontendOptions()
              .SwiftInterfaceCompilerVersion.empty()) {

lib/FrontendTool/LoadedModuleTrace.cpp

@@ -53,6 +53,7 @@ struct SwiftModuleTraceInfo {
   std::string Path;
   bool IsImportedDirectly;
   bool SupportsLibraryEvolution;
+  bool StrictMemorySafety;
 };
 
 struct SwiftMacroTraceInfo {
@@ -65,6 +66,7 @@ struct LoadedModuleTraceFormat {
   unsigned Version;
   Identifier Name;
   std::string Arch;
+  bool StrictMemorySafety;
   std::vector<SwiftModuleTraceInfo> SwiftModules;
   std::vector<SwiftMacroTraceInfo> SwiftMacros;
 };
@@ -80,6 +82,8 @@ template <> struct ObjectTraits<SwiftModuleTraceInfo> {
     out.mapRequired("isImportedDirectly", contents.IsImportedDirectly);
     out.mapRequired("supportsLibraryEvolution",
                     contents.SupportsLibraryEvolution);
+    out.mapRequired("strictMemorySafety",
+                    contents.StrictMemorySafety);
   }
 };
 
@@ -104,6 +108,8 @@ template <> struct ObjectTraits<LoadedModuleTraceFormat> {
 
     out.mapRequired("arch", contents.Arch);
 
+    out.mapRequired("strictMemorySafety", contents.StrictMemorySafety);
+
     // The 'swiftmodules' key is kept for backwards compatibility.
     std::vector<std::string> moduleNames;
     for (auto &m : contents.SwiftModules)
@@ -643,7 +649,8 @@ static void computeSwiftModuleTraceInfo(
            /*IsImportedDirectly=*/
            isImportedDirectly,
            /*SupportsLibraryEvolution=*/
-           depMod->isResilient()});
+           depMod->isResilient(),
+           depMod->strictMemorySafety()});
       buffer.clear();
 
       continue;
@@ -782,8 +789,9 @@ bool swift::emitLoadedModuleTraceIfNeeded(ModuleDecl *mainModule,
   LoadedModuleTraceFormat trace = {
       /*version=*/LoadedModuleTraceFormat::CurrentVersion,
       /*name=*/mainModule->getName(),
-      /*arch=*/ctxt.LangOpts.Target.getArchName().str(), swiftModules,
-      swiftMacros};
+      /*arch=*/ctxt.LangOpts.Target.getArchName().str(),
+      mainModule ? mainModule->strictMemorySafety() : false,
+      swiftModules, swiftMacros};
 
   // raw_fd_ostream is unbuffered, and we may have multiple processes writing,
   // so first write to memory and then dump the buffer to the trace file.

lib/Serialization/ModuleFile.h

@@ -704,6 +704,9 @@ class ModuleFile
   /// \c true if this module was built with complete checking for concurrency.
   bool isConcurrencyChecked() const { return Core->isConcurrencyChecked(); }
 
+  /// \c true if this module was built with strict memory safety.
+  bool strictMemorySafety() const { return Core->strictMemorySafety(); }
+
   /// Associates this module file with the AST node representing it.
   ///
   /// Checks that the file is compatible with the AST module it's being loaded

lib/Serialization/ModuleFileSharedCore.cpp

@@ -221,6 +221,9 @@ static bool readOptionsBlock(llvm::BitstreamCursor &cursor,
     case options_block::SWIFT_INTERFACE_COMPILER_VERSION:
       extendedInfo.setSwiftInterfaceCompilerVersion(blobData);
       break;
+    case options_block::STRICT_MEMORY_SAFETY:
+      extendedInfo.setStrictMemorySafety(true);
+      break;
     default:
       // Unknown options record, possibly for use by a future version of the
       // module format.
@@ -1497,6 +1500,7 @@ ModuleFileSharedCore::ModuleFileSharedCore(
       Bits.CXXStdlibKind = static_cast<uint8_t>(extInfo.getCXXStdlibKind());
       Bits.AllowNonResilientAccess = extInfo.allowNonResilientAccess();
       Bits.SerializePackageEnabled = extInfo.serializePackageEnabled();
+      Bits.StrictMemorySafety = extInfo.strictMemorySafety();
       MiscVersion = info.miscVersion;
       SDKVersion = info.sdkVersion;
       ModuleABIName = extInfo.getModuleABIName();

lib/Serialization/ModuleFileSharedCore.h

@@ -415,8 +415,11 @@ class ModuleFileSharedCore {
     /// Whether this module is built with -package-cmo.
     unsigned SerializePackageEnabled : 1;
 
+    /// Whether this module enabled strict memory safety.
+    unsigned StrictMemorySafety : 1;
+
     // Explicitly pad out to the next word boundary.
-    unsigned : 3;
+    unsigned : 2;
   } Bits = {};
   static_assert(sizeof(ModuleBits) <= 8, "The bit set should be small");
 
@@ -667,6 +670,8 @@ class ModuleFileSharedCore {
 
   bool isConcurrencyChecked() const { return Bits.IsConcurrencyChecked; }
 
+  bool strictMemorySafety() const { return Bits.StrictMemorySafety; }
+
   /// How should \p dependency be loaded for a transitive import via \c this?
   ///
   /// If \p importNonPublicDependencies, more transitive dependencies

lib/Serialization/ModuleFormat.h

@@ -970,6 +970,7 @@ namespace options_block {
     CXX_STDLIB_KIND,
     PUBLIC_MODULE_NAME,
     SWIFT_INTERFACE_COMPILER_VERSION,
+    STRICT_MEMORY_SAFETY,
   };
 
   using SDKPathLayout = BCRecordLayout<
@@ -1066,12 +1067,16 @@ namespace options_block {
     SERIALIZE_PACKAGE_ENABLED
   >;
 
+  using StrictMemorySafetyLayout = BCRecordLayout<
+    STRICT_MEMORY_SAFETY
+  >;
+
   using PublicModuleNameLayout = BCRecordLayout<
     PUBLIC_MODULE_NAME,
     BCBlob
   >;
 
-    using SwiftInterfaceCompilerVersionLayout = BCRecordLayout<
+  using SwiftInterfaceCompilerVersionLayout = BCRecordLayout<
     SWIFT_INTERFACE_COMPILER_VERSION,
     BCBlob // version tuple
   >;