---

yaml
---
r: 346733
b: refs/heads/master
c: 89b29e1
h: refs/heads/master
i:
  346731: b11d6e3

Author: swift-ci

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 12a386df73537ad9f6a227112d8d4075a9b93dd8
+refs/heads/master: 89b29e1cdae194230cc2455f3bd19b640c2880e8
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/include/swift/AST/ASTMangler.h

@@ -158,7 +158,8 @@ class ASTMangler : public Mangler {
                                       GenericSignature *signature,
                                       ResilienceExpansion expansion);
 
-  std::string mangleTypeForDebugger(Type decl, const DeclContext *DC);
+  std::string mangleTypeForDebugger(Type decl, const DeclContext *DC,
+                                    bool verify=false);
 
   std::string mangleDeclType(const ValueDecl *decl);
 

trunk/include/swift/AST/IRGenOptions.h

@@ -197,6 +197,9 @@ class IRGenOptions {
   /// Enable chaining of dynamic replacements.
   unsigned EnableDynamicReplacementChaining : 1;
 
+  /// Disable round-trip verification of mangled debug types.
+  unsigned DisableRoundTripDebugTypes : 1;
+
   /// Path to the profdata file to be used for PGO, or the empty string.
   std::string UseProfile = "";
 
@@ -232,6 +235,7 @@ class IRGenOptions {
         EnableResilienceBypass(false), LazyInitializeClassMetadata(false),
         UseIncrementalLLVMCodeGen(true), UseSwiftCall(false),
         GenerateProfile(false), EnableDynamicReplacementChaining(false),
+        DisableRoundTripDebugTypes(false),
         CmdArgs(), SanitizeCoverage(llvm::SanitizerCoverageOptions()),
         TypeInfoFilter(TypeInfoDumpFilter::All) {}
 

trunk/lib/AST/ASTMangler.cpp

@@ -42,6 +42,10 @@
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/CommandLine.h"
 
+#ifndef NDEBUG
+#include "swift/AST/ASTDemangler.h"
+#endif
+
 using namespace swift;
 using namespace swift::Mangle;
 
@@ -360,7 +364,30 @@ std::string ASTMangler::mangleReabstractionThunkHelper(
   return finalize();
 }
 
-std::string ASTMangler::mangleTypeForDebugger(Type Ty, const DeclContext *DC) {
+#ifndef NDEBUG
+static bool areTypesReallyEqual(Type lhs, Type rhs) {
+  // Due to an oversight, escaping and non-escaping @convention(block)
+  // are mangled identically.
+  auto eraseEscapingBlock = [](Type t) -> Type {
+    return t.transform([](Type t) -> Type {
+      if (auto *fnType = t->getAs<FunctionType>()) {
+        if (fnType->getExtInfo().getRepresentation()
+              == FunctionTypeRepresentation::Block) {
+          return FunctionType::get(fnType->getParams(),
+                                   fnType->getResult(),
+                                   fnType->getExtInfo().withNoEscape(true));
+        }
+      }
+      return t;
+    });
+  };
+
+  return eraseEscapingBlock(lhs)->isEqual(eraseEscapingBlock(rhs));
+}
+#endif
+
+std::string ASTMangler::mangleTypeForDebugger(Type Ty, const DeclContext *DC,
+                                              bool verify) {
   PrettyStackTraceType prettyStackTrace(Ty->getASTContext(),
                                         "mangling type for debugger", Ty);
 
@@ -373,7 +400,33 @@ std::string ASTMangler::mangleTypeForDebugger(Type Ty, const DeclContext *DC) {
 
   appendType(Ty);
   appendOperator("D");
-  return finalize();
+  std::string result = finalize();
+
+  if (!verify)
+    return result;
+
+  // Make sure we can reconstruct mangled types for the debugger.
+#ifndef NDEBUG
+  auto &Ctx = Ty->getASTContext();
+  Type Reconstructed = Demangle::getTypeForMangling(Ctx, result);
+  if (!Reconstructed) {
+    llvm::errs() << "Failed to reconstruct type for " << result << "\n";
+    llvm::errs() << "Original type:\n";
+    Ty->dump();
+    abort();
+  } else if (!Reconstructed->isEqual(Ty)) {
+    if (!areTypesReallyEqual(Reconstructed, Ty)) {
+      llvm::errs() << "Incorrect reconstructed type for " << result << "\n";
+      llvm::errs() << "Original type:\n";
+      Ty->dump();
+      llvm::errs() << "Reconstructed type:\n";
+      Reconstructed->dump();
+      abort();
+    }
+  }
+#endif
+
+  return result;
 }
 
 std::string ASTMangler::mangleDeclType(const ValueDecl *decl) {

trunk/lib/IRGen/GenDecl.cpp

@@ -1447,13 +1447,16 @@ getIRLinkage(const UniversalLinkageInfo &info, SILLinkage linkage,
     return {llvm::GlobalValue::ExternalLinkage, PublicDefinitionVisibility,
             ExportedStorage};
 
+  case SILLinkage::PublicNonABI:
+    return isDefinition ? RESULT(WeakODR, Hidden, Default)
+                        : RESULT(External, Hidden, Default);
+
   case SILLinkage::Shared:
   case SILLinkage::SharedExternal:
     return isDefinition ? RESULT(LinkOnceODR, Hidden, Default)
                         : RESULT(External, Hidden, Default);
 
   case SILLinkage::Hidden:
-  case SILLinkage::PublicNonABI:
     return RESULT(External, Hidden, Default);
 
   case SILLinkage::Private: {

trunk/lib/IRGen/IRGenDebugInfo.cpp

@@ -698,7 +698,8 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
 
     Mangle::ASTMangler Mangler;
     std::string Name = Mangler.mangleTypeForDebugger(
-        Ty, DbgTy.getDeclContext());
+        Ty, DbgTy.getDeclContext(),
+        !Opts.DisableRoundTripDebugTypes);
     return BumpAllocatedString(Name);
   }
 

trunk/test/IRGen/sil_linkage.sil

@@ -5,7 +5,7 @@ sil_stage canonical
 // CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @public_fragile_function_test() {{.*}} {
 // CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @public_transparent_fragile_function_test() {{.*}} {
 // CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @public_transparent_function_test() {{.*}} {
-// CHECK: define hidden swiftcc void @public_non_abi_function_test() {{.*}} {
+// CHECK: define weak_odr hidden swiftcc void @public_non_abi_function_test() {{.*}} {
 // CHECK: define hidden swiftcc void @hidden_fragile_function_test() {{.*}} {
 // CHECK: define linkonce_odr hidden swiftcc void @shared_fragile_function_test() {{.*}} {
 // CHECK: define{{( internal)?}} swiftcc void @private_fragile_function_test() {{.*}} {

trunk/utils/build-script-impl

@@ -2541,12 +2541,12 @@ for host in "${ALL_HOSTS[@]}"; do
                       -DLLDB_INCLUDE_TESTS:BOOL=$(false_true ${BUILD_TOOLCHAIN_ONLY})
                   )
 
-                  if [[ ${LLDB_BUILD_ON_MACOS} ]] ; then
+                  if [[ "$(uname -s)" == "Darwin" ]] ; then
                     cmake_options+=(
                       -DLLDB_BUILD_FRAMEWORK:BOOL=TRUE
                       -DLLDB_CODESIGN_IDENTITY=""
                     )
-                    if "${ENABLE_ASAN}" ]] ; then
+                    if [[ "${ENABLE_ASAN}" ]] ; then
                       # Limit the number of parallel tests
                       LLVM_LIT_ARGS="${LLVM_LIT_ARGS} --threads=$(sysctl hw.physicalcpu | awk '{ print $2 }')"
                     fi