IRGen: Start a type verifier to fuzz static type info against runtime type info.

We've had a rash of bugs due to inconsistencies between how IRGen and the runtime think types are laid out. Add a '-verify-type-layout' mode to the frontend that causes IRGen to emit a bunch of code that compares its static assumptions against what the runtime value witness does.

Swift SVN r24918

Author: jckarter

Diff for: include/swift/AST/IRGenOptions.h

@@ -100,14 +100,17 @@ class IRGenOptions {
 
   /// Special codegen for playgrounds.
   unsigned Playground : 1;
+  
+  /// Emit code to verify that static and runtime type layout are consistent.
+  unsigned VerifyTypeLayout : 1;
 
   IRGenOptions() : OutputKind(IRGenOutputKind::LLVMAssembly), Verify(true),
                    Optimize(false), DebugInfoKind(IRGenDebugInfoKind::None),
                    UseJIT(false), EnableDynamicValueTypeLayout(false),
                    DisableLLVMOptzns(false), DisableLLVMARCOpts(false),
                    DisableLLVMSLPVectorizer(false),
                    DisableFPElim(true), HasUnderlyingModule(false),
-                   Playground(false) {}
+                   Playground(false), VerifyTypeLayout(false) {}
 };
 
 } // end namespace swift

Diff for: include/swift/Option/FrontendOptions.td

@@ -250,6 +250,9 @@ def disable_func_sig_opts : Flag<["-"], "disable-func-sig-opts">,
 
 def interpret : Flag<["-"], "interpret">, HelpText<"Immediate mode">, ModeOpt;
 
+def verify_type_layout : Flag<["-"], "verify-type-layout">,
+  HelpText<"Verify compile-time and runtime type layout information">;
+
 def enable_guaranteed_self : Flag<["-"], "enable-guaranteed-self">,
   HelpText<"Enable the passing of self as a guaranteed parameter">;
 

Diff for: lib/Frontend/CompilerInvocation.cpp

@@ -932,6 +932,9 @@ static bool ParseIRGenArgs(IRGenOptions &Opts, ArgList &Args,
   if (Args.hasArg(OPT_use_jit))
     Opts.UseJIT = true;
 
+  if (Args.hasArg(OPT_verify_type_layout))
+    Opts.VerifyTypeLayout = true;
+  
   return false;
 }
 

Diff for: lib/IRGen/CMakeLists.txt

@@ -27,6 +27,7 @@ add_swift_library(swiftIRGen
   Linking.cpp
   SwiftTargetInfo.cpp
   StructLayout.cpp
+  TypeLayoutVerifier.cpp
   UnimplementedTypeInfo.cpp
   LINK_LIBRARIES
     swiftAST

Diff for: lib/IRGen/GenDecl.cpp

@@ -43,6 +43,7 @@
 #include "GenClass.h"
 #include "GenObjC.h"
 #include "GenMeta.h"
+#include "GenType.h"
 #include "IRGenDebugInfo.h"
 #include "IRGenFunction.h"
 #include "IRGenModule.h"
@@ -787,6 +788,38 @@ void IRGenModule::emitVTableStubs() {
   }
 }
 
+void IRGenModule::emitTypeVerifier() {
+  // Find the entry point.
+  SILFunction *EntryPoint = SILMod->lookUpFunction(SWIFT_ENTRY_POINT_FUNCTION);
+
+  if (!EntryPoint)
+    return;
+  
+  llvm::Function *EntryFunction = Module.getFunction(EntryPoint->getName());
+  if (!EntryFunction)
+    return;
+  
+  // Create a new function to contain our logic.
+  auto fnTy = llvm::FunctionType::get(VoidTy, /*varArg*/ false);
+  auto VerifierFunction = llvm::Function::Create(fnTy,
+                                             llvm::GlobalValue::PrivateLinkage,
+                                             "type_verifier",
+                                             getModule());
+  
+  // Insert a call into the entry function.
+  {
+    llvm::BasicBlock *EntryBB = &EntryFunction->getEntryBlock();
+    llvm::BasicBlock::iterator IP = EntryBB->getFirstInsertionPt();
+    IRBuilder Builder(getLLVMContext());
+    Builder.llvm::IRBuilderBase::SetInsertPoint(EntryBB, IP);
+    Builder.CreateCall(VerifierFunction);
+  }
+  
+  IRGenFunction VerifierIGF(*this, VerifierFunction);
+  emitTypeLayoutVerifier(VerifierIGF, TypesToVerify);
+  VerifierIGF.Builder.CreateRetVoid();
+}
+
 /// Get SIL-linkage for something that's not required to be visible
 /// and doesn't actually need to be uniqued.
 static SILLinkage getNonUniqueSILLinkage(FormalLinkage linkage,

Diff for: lib/IRGen/GenOpaque.cpp

@@ -583,6 +583,16 @@ llvm::Value *irgen::emitLoadOfIsPOD(IRGenFunction &IGF, llvm::Value *wtable) {
                                   wtable->getName() + ".isPOD");
 }
 
+/// Load the 'isBitwiseTakable' valueWitness from the given table as an i1.
+llvm::Value *irgen::emitLoadOfIsBitwiseTakable(IRGenFunction &IGF,
+                                               llvm::Value *wtable) {
+  auto flags = emitLoadOfValueWitness(IGF, wtable, ValueWitness::Flags);
+  auto mask = IGF.IGM.getSize(Size(ValueWitnessFlags::IsNonBitwiseTakable));
+  auto masked = IGF.Builder.CreateAnd(flags, mask);
+  return IGF.Builder.CreateICmpEQ(masked, IGF.IGM.getSize(Size(0)),
+                                  wtable->getName() + ".isBitwiseTakable");
+}
+
 /// Load the 'isInline' valueWitness from the given table as an i1.
 llvm::Value *irgen::emitLoadOfIsInline(IRGenFunction &IGF,
                                        llvm::Value *wtable) {
@@ -593,7 +603,26 @@ llvm::Value *irgen::emitLoadOfIsInline(IRGenFunction &IGF,
                                   wtable->getName() + ".isInline");
 }
 
+/// Load the 'hasExtraInhabitants' valueWitness from the given table as an i1.
+llvm::Value *irgen::emitLoadOfHasExtraInhabitants(IRGenFunction &IGF,
+                                                  llvm::Value *wtable) {
+  auto flags = emitLoadOfValueWitness(IGF, wtable, ValueWitness::Flags);
+  auto mask = IGF.IGM.getSize(Size(ValueWitnessFlags::Enum_HasExtraInhabitants));
+  auto masked = IGF.Builder.CreateAnd(flags, mask);
+  return IGF.Builder.CreateICmpNE(masked, IGF.IGM.getSize(Size(0)),
+                                  wtable->getName() + ".hasExtraInhabitants");
+}
+
 /// Load the 'stride' value witness from the given table as a size_t.
 llvm::Value *irgen::emitLoadOfStride(IRGenFunction &IGF, llvm::Value *wtable) {
   return emitLoadOfValueWitness(IGF, wtable, ValueWitness::Stride);
 }
+
+llvm::Value *irgen::emitLoadOfExtraInhabitantCount(IRGenFunction &IGF,
+                                                   llvm::Value *wtable) {
+  auto xiFlags = emitLoadOfValueWitness(IGF, wtable,
+                                        ValueWitness::ExtraInhabitantFlags);
+  auto mask = IGF.IGM.getSize(
+                          Size(ExtraInhabitantFlags::NumExtraInhabitantsMask));
+  return IGF.Builder.CreateAnd(xiFlags, mask);
+}

Diff for: lib/IRGen/GenOpaque.h

@@ -157,8 +157,22 @@ namespace irgen {
   /// Emit a load of the 'isPOD' value witness.
   llvm::Value *emitLoadOfIsPOD(IRGenFunction &IGF, llvm::Value *vwtable);
 
+  /// Emit a load of the 'isBitwiseTakable' value witness.
+  llvm::Value *emitLoadOfIsBitwiseTakable(IRGenFunction &IGF,
+                                          llvm::Value *vwtable);
+
   /// Emit a load of the 'isInline' value witness.
   llvm::Value *emitLoadOfIsInline(IRGenFunction &IGF, llvm::Value *vwtable);
+
+  /// Emit a load of the 'hasExtraInhabitants' value witness.
+  llvm::Value *emitLoadOfHasExtraInhabitants(IRGenFunction &IGF,
+                                             llvm::Value *vwtable);
+  
+  /// Emit a load of the 'extraInhabitantCount' value witness.
+  /// The type must be dynamically known to have extra inhabitant witnesses.
+  llvm::Value *emitLoadOfExtraInhabitantCount(IRGenFunction &IGF,
+                                              llvm::Value *vwtable);
+
 } // end namespace irgen
 } // end namespace swift
 

Diff for: lib/IRGen/GenType.cpp

@@ -16,6 +16,7 @@
 
 #include "swift/AST/CanTypeVisitor.h"
 #include "swift/AST/Decl.h"
+#include "swift/AST/IRGenOptions.h"
 #include "swift/AST/PrettyStackTrace.h"
 #include "swift/AST/Types.h"
 #include "swift/SIL/SILModule.h"
@@ -1181,6 +1182,16 @@ TypeCacheEntry TypeConverter::getTypeEntry(CanType canonicalTy) {
     convertedTI->NextConverted = FirstType;
     FirstType = convertedTI;
   }
+  
+  // Verify fixed-layout, non-dependent, nominal types.
+  // TODO: A better mechanism to control what types get verified.
+  if (IGM.Opts.VerifyTypeLayout
+      && isa<FixedTypeInfo>(convertedTI)
+      && canonicalTy->getAnyNominal()
+      && !canonicalTy->isDependentType()
+      && !canonicalTy->hasArchetype()) {
+    IGM.TypesToVerify.push_back(canonicalTy);
+  }
 
   return convertedTI;
 }

Diff for: lib/IRGen/GenType.h

@@ -172,7 +172,7 @@ class TypeConverter {
 
   ArchetypeType *getExemplarArchetype(ArchetypeType *t);
   CanType getExemplarType(CanType t);
-
+  
   class Types_t {
     llvm::DenseMap<TypeBase*, TypeCacheEntry> IndependentCache;
     llvm::DenseMap<TypeBase*, TypeCacheEntry> DependentCache;
@@ -218,6 +218,10 @@ class GenericContextScope {
     TC.popGenericContext(sig);
   }
 };
+
+/// Generate code to verify that static type assumptions agree with the runtime.
+void emitTypeLayoutVerifier(IRGenFunction &IGF,
+                            ArrayRef<CanType> formalTypes);
 
 } // end namespace irgen
 } // end namespace swift

Diff for: lib/IRGen/IRGen.cpp

@@ -177,6 +177,10 @@ static std::unique_ptr<llvm::Module> performIRGeneration(IRGenOptions &Opts,
   // Emit symbols for eliminated dead methods.
   IGM.emitVTableStubs();
 
+  // Verify type layout if we were asked to.
+  if (Opts.VerifyTypeLayout)
+    IGM.emitTypeVerifier();
+
   // Register our info with the runtime if needed.
   if (Opts.UseJIT)
     IGM.emitRuntimeRegistration();

Diff for: lib/IRGen/IRGenModule.h

@@ -286,6 +286,7 @@ class IRGenModule {
 
 private:
   TypeConverter &Types;
+  std::vector<CanType> TypesToVerify;
   friend class TypeConverter;
 
   const clang::ASTContext *ClangASTContext;
@@ -493,6 +494,7 @@ private:                            \
   void emitRuntimeRegistration();
   void emitLazyDefinitions();
   void emitVTableStubs();
+  void emitTypeVerifier();
 private:
   void emitGlobalDecl(Decl *D);
   void emitExternalDefinition(Decl *D);