Merge pull request #2169 from apple/demangle

[runtime] Fortify the swift_demangle API.

Author: AnnaZaks

include/swift/Runtime/Portability.h

@@ -0,0 +1,23 @@
+//===--- Portability.h -----------------------------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2016 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Includes stub APIs that make the portable runtime easier to write.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_RUNTIME_PORTABILITY_H
+#define SWIFT_RUNTIME_PORTABILITY_H
+#include <stddef.h>
+
+size_t _swift_strlcpy(char *dst, const char *src, size_t maxlen);
+
+#endif

stdlib/public/core/Misc.swift

@@ -121,30 +121,6 @@ func _typeByName(_ name: String) -> Any.Type? {
     return type
   }
 }
- 
-@warn_unused_result
-@_silgen_name("swift_stdlib_demangleName")
-func _stdlib_demangleNameImpl(
-  _ mangledName: UnsafePointer<UInt8>,
-  _ mangledNameLength: UInt,
-  _ demangledName: UnsafeMutablePointer<String>)
-
-// NB: This function is not used directly in the Swift codebase, but is
-// exported for Xcode support. Please coordinate before changing.
-@warn_unused_result
-public // @testable
-func _stdlib_demangleName(_ mangledName: String) -> String {
-  let mangledNameUTF8 = Array(mangledName.utf8)
-  return mangledNameUTF8.withUnsafeBufferPointer {
-    (mangledNameUTF8) in
-    let (_, demangledName) = _withUninitializedString {
-      _stdlib_demangleNameImpl(
-        mangledNameUTF8.baseAddress!, UInt(mangledNameUTF8.endIndex),
-        $0)
-    }
-    return demangledName
-  }
-}
 
 /// Returns `floor(log(x))`.  This equals to the position of the most
 /// significant non-zero bit, or 63 - number-of-zeros before it.

stdlib/public/runtime/CMakeLists.txt

@@ -47,6 +47,7 @@ set(swift_runtime_sources
     MetadataLookup.cpp
     Mutex.cpp
     Once.cpp
+    Portability.cpp
     ProtocolConformance.cpp
     Reflection.cpp
     RuntimeEntrySymbols.cpp

stdlib/public/runtime/Portability.cpp

@@ -0,0 +1,29 @@
+//===--- Portability.cpp - -----------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2016 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
+//
+//===---------------------------------------------------------------------===//
+//
+// Implementations of the stub APIs that make portable runtime easier to write.
+//
+//===---------------------------------------------------------------------===//
+
+#include "swift/Runtime/Portability.h"
+#include <cstring>
+
+size_t _swift_strlcpy(char *dst, const char *src, size_t maxlen) {
+  const size_t srclen = std::strlen(src);
+  if (srclen < maxlen) {
+    std::memmove(dst, src, srclen + 1);
+  } else if (maxlen != 0) {
+    std::memmove(dst, src, maxlen - 1);
+    dst[maxlen - 1] = '\0';
+  }
+  return srclen;
+}

stdlib/public/runtime/Reflection.mm

@@ -17,6 +17,7 @@
 #include "swift/Runtime/Enum.h"
 #include "swift/Basic/Demangle.h"
 #include "swift/Runtime/Debug.h"
+#include "swift/Runtime/Portability.h"
 #include "Private.h"
 #include <cassert>
 #include <cstdio>
@@ -1190,16 +1191,63 @@ static Mirror ObjC_getMirrorForSuperclass(Class sup,
 }
 
 // NB: This function is not used directly in the Swift codebase, but is
-// exported for Xcode support. Please coordinate before changing.
+// exported for Xcode support and is used by the sanitizers. Please coordinate
+// before changing.
+//
+/// Demangles a Swift symbol name.
+///
+/// \param mangledName is the symbol name that needs to be demangled.
+/// \param mangledNameLength is the length of the string that should be
+/// demangled.
+/// \param outputBuffer is the user provided buffer where the demangled name
+/// will be placed. If nullptr, a new buffer will be malloced. In that case,
+/// the user of this API is responsible for freeing the returned buffer.
+/// \param outputBufferSize is the size of the output buffer. If the demangled
+/// name does not fit into the outputBuffer, the output will be truncated and
+/// the size will be updated, indicating how large the buffer should be.
+/// \param flags can be used to select the demangling style. TODO: We should
+//// define what these will be.
+/// \returns the demangled name. Returns nullptr if the input String is not a
+/// Swift mangled name.
 SWIFT_RUNTIME_EXPORT
-extern "C" void swift_stdlib_demangleName(const char *mangledName,
-                                          size_t mangledNameLength,
-                                          String *demangledName) {
+extern "C" char *swift_demangle(const char *mangledName,
+                                size_t mangledNameLength,
+                                char *outputBuffer,
+                                size_t *outputBufferSize,
+                                uint32_t flags) {
+  if (flags != 0) {
+    swift::fatalError(0, "Only 'flags' value of '0' is currently supported.");
+  }
+  if (outputBuffer != nullptr && outputBufferSize == nullptr) {
+    swift::fatalError(0, "'outputBuffer' is passed but the size is 'nullptr'.");
+  }
+
+  // Check if we are dealing with Swift mangled name, otherwise, don't try
+  // to demangle and send indication to the user.
+  if (mangledName[0] != '_' || mangledName[1] != 'T') {
+    return nullptr;
+  }
+
+  // Demangle the name.
   auto options = Demangle::DemangleOptions();
   options.DisplayDebuggerGeneratedModule = false;
   auto result =
       Demangle::demangleSymbolAsString(mangledName,
                                        mangledNameLength,
                                        options);
-  new (demangledName) String(result.data(), result.size());
+
+  // If the output buffer is not provided, malloc memory ourselves.
+  if (outputBuffer == nullptr || *outputBufferSize == 0) {
+    return strdup(result.c_str());
+  }
+
+  // Indicate a failure if the result does not fit and will be truncated
+  // and set the required outputBufferSize.
+  if (*outputBufferSize < result.length() + 1) {
+    *outputBufferSize = result.length() + 1;
+  }
+
+  // Copy into the provided buffer.
+  _swift_strlcpy(outputBuffer, result.c_str(), *outputBufferSize);
+  return outputBuffer;
 }

test/1_stdlib/Runtime.swift

@@ -9,6 +9,37 @@ import StdlibUnittest
 import SwiftShims
 
 
+@warn_unused_result
+@_silgen_name("swift_demangle")
+public
+func _stdlib_demangleImpl(
+  mangledName: UnsafePointer<UInt8>?,
+  mangledNameLength: UInt,
+  outputBuffer: UnsafeMutablePointer<UInt8>?,
+  outputBufferSize: UnsafeMutablePointer<UInt>?,
+  flags: UInt32
+) -> UnsafeMutablePointer<CChar>?
+
+@warn_unused_result
+func _stdlib_demangleName(_ mangledName: String) -> String {
+  return mangledName.nulTerminatedUTF8.withUnsafeBufferPointer {
+    (mangledNameUTF8) in
+
+    let demangledNamePtr = _stdlib_demangleImpl(
+      mangledName: mangledNameUTF8.baseAddress,
+      mangledNameLength: UInt(mangledNameUTF8.count - 1),
+      outputBuffer: nil,
+      outputBufferSize: nil,
+      flags: 0)
+
+    if let demangledNamePtr = demangledNamePtr {
+      let demangledName = String(cString: demangledNamePtr)
+      _swift_stdlib_free(demangledNamePtr)
+      return demangledName
+    }
+    return mangledName
+  }
+}
 
 var swiftObjectCanaryCount = 0
 class SwiftObjectCanary {