[stdlib][oslog] Create an SPI _globalStringTablePointer that exposes

the builtin.globalStringTablePointer to the new OSLog overlay.

Modify the new OSLog implementation to use this SPI instead of
`withCString` to pass the (compiler-generated) format string to
the C os_log_impl ABI.

Move the OSLogOptimization pass before constant propagation in
the pass pipeline so that the SPI and the builtin it uses can be
folded to a string_literal instruction.

Update OSLogTests to work with the changes in the implementation.

Author: ravikandhadai

lib/SILOptimizer/Mandatory/OSLogOptimization.cpp

@@ -22,8 +22,10 @@
 /// arguments are packed. This pass is closely tied to the implementation of
 /// the log APIs.
 ///
-/// Pass Dependencies: MandatoryInlining. This pass also uses
-/// `ConstExprStepEvaluator` defined in `Utils/ConstExpr.cpp`.
+/// Pass Dependencies:  This pass depends on MandatoryInlining and Mandatory
+/// Linking happening before this pass and ConstantPropagation happening after
+/// this pass. This pass also uses `ConstExprStepEvaluator` defined in
+/// `Utils/ConstExpr.cpp`.
 ///
 /// Algorithm Overview:
 ///

lib/SILOptimizer/PassManager/PassPipeline.cpp

@@ -114,6 +114,13 @@ static void addMandatoryOptPipeline(SILPassPipelinePlan &P) {
   // SSA based diagnostics.
   P.addPredictableMemoryAccessOptimizations();
 
+  // This phase performs optimizations necessary for correct interoperation of
+  // Swift os log APIs with C os_log ABIs.
+  // Pass dependencies: this pass depends on MandatoryInlining and Mandatory
+  // Linking happening before this pass and ConstantPropagation happening after
+  // this pass.
+  P.addOSLogOptimization();
+
   // Diagnostic ConstantPropagation must be rerun on deserialized functions
   // because it is sensitive to the assert configuration.
   // Consequently, certain optimization passes beyond this point will also rerun.
@@ -129,10 +136,6 @@ static void addMandatoryOptPipeline(SILPassPipelinePlan &P) {
   P.addYieldOnceCheck();
   P.addEmitDFDiagnostics();
 
-  // This phase performs optimizations necessary for correct interoperation of
-  // Swift os log APIs with C os_log ABIs.
-  P.addOSLogOptimization();
-
   // Canonical swift requires all non cond_br critical edges to be split.
   P.addSplitNonCondBrCriticalEdges();
 }

stdlib/private/OSLog/OSLog.swift

@@ -66,32 +66,31 @@ internal func osLog(
   let preamble = message.interpolation.preamble
   let argumentCount = message.interpolation.argumentCount
   let bufferSize = message.bufferSize
+  let formatStringPointer = _getGlobalStringTablePointer(formatString)
 
   // Code that will execute at runtime.
-  let arguments = message.interpolation.arguments
-  formatString.withCString { cFormatString in
+  guard logObject.isEnabled(type: logLevel) else { return }
 
-    guard logObject.isEnabled(type: logLevel) else { return }
+  let arguments = message.interpolation.arguments
 
-    // Ideally, we could stack allocate the buffer as it is local to this
-    // function and also its size is a compile-time constant.
-    let bufferMemory =
-      UnsafeMutablePointer<UInt8>.allocate(capacity: bufferSize)
-    var builder = OSLogByteBufferBuilder(bufferMemory)
+  // Ideally, we could stack allocate the buffer as it is local to this
+  // function and also its size is a compile-time constant.
+  let bufferMemory =
+    UnsafeMutablePointer<UInt8>.allocate(capacity: bufferSize)
+  var builder = OSLogByteBufferBuilder(bufferMemory)
 
-    builder.serialize(preamble)
-    builder.serialize(argumentCount)
-    arguments.serialize(into: &builder)
+  builder.serialize(preamble)
+  builder.serialize(argumentCount)
+  arguments.serialize(into: &builder)
 
-    ___os_log_impl(UnsafeMutableRawPointer(mutating: #dsohandle),
-                   logObject,
-                   logLevel,
-                   cFormatString,
-                   bufferMemory,
-                   UInt32(bufferSize))
+  ___os_log_impl(UnsafeMutableRawPointer(mutating: #dsohandle),
+                 logObject,
+                 logLevel,
+                 formatStringPointer,
+                 bufferMemory,
+                 UInt32(bufferSize))
 
-    bufferMemory.deallocate()
-  }
+  bufferMemory.deallocate()
 }
 
 /// A test helper that constructs a byte buffer and a format string from an

stdlib/private/OSLog/OSLogMessage.swift

@@ -48,7 +48,7 @@ public var maxOSLogArgumentCount: UInt8 { return 48 }
 
 @usableFromInline
 @_transparent
-internal var bitsPerByte: Int { return 8 }
+internal var logBitsPerByte: Int { return 3 }
 
 /// Represents a string interpolation passed to the log APIs.
 ///
@@ -458,7 +458,7 @@ internal struct OSLogSerializationInfo {
   @usableFromInline
   @_transparent
   internal static func sizeForEncoding(_ type: Int.Type) -> Int {
-    return Int.bitWidth / bitsPerByte
+    return Int.bitWidth &>> logBitsPerByte
   }
 }
 

stdlib/public/core/Builtin.swift

@@ -965,3 +965,14 @@ public func _openExistential<ExistentialType, ContainedType, ResultType>(
   Builtin.unreachable()
 }
 
+/// Given a string that is constructed from a string literal, return a pointer
+/// to the global string table location that contains the string literal.
+/// This function will trap when it is invoked on strings that are not
+/// constructed from literals or if the construction site of the string is not
+/// in the function containing the call to this SPI.
+@_transparent
+@_alwaysEmitIntoClient
+public // @SPI(OSLog)
+func _getGlobalStringTablePointer(_ constant: String) -> UnsafePointer<CChar> {
+  return UnsafePointer<CChar>(Builtin.globalStringTablePointer(constant));
+}

test/IRGen/builtins.swift

@@ -809,6 +809,7 @@ throw MyError.A
 // CHECK-LABEL: define {{.*}}globalStringTablePointer
 // CHECK: call void @llvm.trap()
 // CHECK: ret i8* undef
+@_transparent
 func globalStringTablePointerUse(_ str: String) -> Builtin.RawPointer {
   return Builtin.globalStringTablePointer(str);
 }

test/SILOptimizer/OSLogPrototypeCompileDiagnostics.swift

@@ -15,21 +15,25 @@ if #available(OSX 10.12, iOS 10.0, watchOS 3.0, tvOS 10.0, *) {
     // FIXME: log APIs must always be passed a string interpolation literal.
     // Diagnose this.
     h.log(level: .debug, message)
+      // expected-error @-1 {{globalStringTablePointer builtin must used only on string literals}}
   }
 
   func testNonconstantFormatOption(h: Logger, formatOpt: IntFormat) {
     h.log(level: .debug, "Minimum integer value: \(Int.min, format: formatOpt)")
     // expected-error @-1 {{'OSLogInterpolation.formatString' is not a constant: formatting and privacy options must be literals}}
+    // expected-error @-2 {{globalStringTablePointer builtin must used only on string literals}}
   }
 
   func testNonconstantPrivacyOption(h: Logger,  privacyOpt: Privacy) {
     h.log(level: .debug, "Minimum integer value: \(Int.min, privacy: privacyOpt)")
     // expected-error @-1 {{'OSLogInterpolation.formatString' is not a constant: formatting and privacy options must be literals}}
+    // expected-error @-2 {{globalStringTablePointer builtin must used only on string literals}}
   }
 
-  // FIXME: the following two tests should produce diagnostics and are not
+  // FIXME: the following test should produce diagnostics and is a not
   // valid uses of the log APIs. The string interpolation passed to the os log
   // call must be apart of the log call, it cannot be constructed earlier.
+  // It nonetheless works fine, but should be rejected.
   func testNoninlinedOSLogMessage(h: Logger) {
     let logMessage: OSLogMessage = "Minimum integer value: \(Int.min)"
     h.log(level: .debug, logMessage)
@@ -41,6 +45,7 @@ if #available(OSX 10.12, iOS 10.0, watchOS 3.0, tvOS 10.0, *) {
       return;
     }
     h.log(level: .debug, logMessage)
+      // expected-error @-1 {{globalStringTablePointer builtin must used only on string literals}}
   }
 }