diff --git a/benchmark/single-source/ObjectiveCBridging.swift b/benchmark/single-source/ObjectiveCBridging.swift
index 1b9c04e980e27..bb725a84ff2be 100644
--- a/benchmark/single-source/ObjectiveCBridging.swift
+++ b/benchmark/single-source/ObjectiveCBridging.swift
@@ -100,6 +100,42 @@ public let benchmarks = [
   BenchmarkInfo(name: "NSDictionary.bridged.enumerate",
                   runFunction: run_BridgedNSDictionaryEnumerate, tags: t,
                   setUpFunction: setup_bridgedDictionaries),
+  BenchmarkInfo(name: "NSString.bridged.byteCount.ascii.ascii",
+                  runFunction: run_BridgedNSStringLengthASCII_ASCII, tags: ts,
+                  setUpFunction: setup_bridgedStrings),
+  BenchmarkInfo(name: "NSString.bridged.byteCount.ascii.utf8",
+                  runFunction: run_BridgedNSStringLengthASCII_UTF8, tags: ts,
+                  setUpFunction: setup_bridgedStrings),
+  BenchmarkInfo(name: "NSString.bridged.byteCount.ascii.utf16",
+                  runFunction: run_BridgedNSStringLengthASCII_UTF16, tags: ts,
+                  setUpFunction: setup_bridgedStrings),
+  BenchmarkInfo(name: "NSString.bridged.byteCount.ascii.macroman",
+                  runFunction: run_BridgedNSStringLengthASCII_MacRoman, tags: ts,
+                  setUpFunction: setup_bridgedStrings),
+  BenchmarkInfo(name: "NSString.bridged.byteCount.utf8.utf8",
+                  runFunction: run_BridgedNSStringLengthUTF8_UTF8, tags: ts,
+                  setUpFunction: setup_bridgedStrings),
+  BenchmarkInfo(name: "NSString.bridged.byteCount.utf8.utf16",
+                  runFunction: run_BridgedNSStringLengthUTF8_UTF16, tags: ts,
+                  setUpFunction: setup_bridgedStrings),
+  BenchmarkInfo(name: "NSString.bridged.maxByteCount.ascii.ascii",
+                  runFunction: run_BridgedNSStringMaxLengthASCII_ASCII, tags: ts,
+                  setUpFunction: setup_bridgedStrings),
+  BenchmarkInfo(name: "NSString.bridged.maxByteCount.ascii.utf8",
+                  runFunction: run_BridgedNSStringMaxLengthASCII_UTF8, tags: ts,
+                  setUpFunction: setup_bridgedStrings),
+  BenchmarkInfo(name: "NSString.bridged.maxByteCount.ascii.utf16",
+                  runFunction: run_BridgedNSStringMaxLengthASCII_UTF16, tags: ts,
+                  setUpFunction: setup_bridgedStrings),
+  BenchmarkInfo(name: "NSString.bridged.maxByteCount.ascii.macroman",
+                  runFunction: run_BridgedNSStringMaxLengthASCII_MacRoman, tags: ts,
+                  setUpFunction: setup_bridgedStrings),
+  BenchmarkInfo(name: "NSString.bridged.maxByteCount.utf8.utf8",
+                  runFunction: run_BridgedNSStringMaxLengthUTF8_UTF8, tags: ts,
+                  setUpFunction: setup_bridgedStrings),
+  BenchmarkInfo(name: "NSString.bridged.maxByteCount.utf8.utf16",
+                  runFunction: run_BridgedNSStringMaxLengthUTF8_UTF16, tags: ts,
+                  setUpFunction: setup_bridgedStrings),
 ]
 
 #if _runtime(_ObjC)
@@ -801,6 +837,8 @@ var bridgedDictionaryOfNumbersToNumbers:NSDictionary! = nil
 var bridgedArrayMutableCopy:NSMutableArray! = nil
 var nsArray:NSArray! = nil
 var nsArrayMutableCopy:NSMutableArray! = nil
+var bridgedASCIIString:NSString! = nil
+var bridgedUTF8String:NSString! = nil
 #endif
 
 public func setup_bridgedArrays() {
@@ -822,6 +860,14 @@ public func setup_bridgedDictionaries() {
   bridgedDictionaryOfNumbersToNumbers = numDict as NSDictionary
 }
 
+public func setup_bridgedStrings() {
+  #if _runtime(_ObjC)
+  let str = Array(repeating: "The quick brown fox jumps over the lazy dog.", count: 100).joined()
+  bridgedASCIIString = str as NSString
+  let str2 = Array(repeating: "The quick brown fox jumps over the lazy dög.", count: 100).joined()
+  bridgedUTF8String = str2 as NSString
+  #endif
+}
 
 @inline(never)
 public func run_BridgedNSArrayObjectAtIndex(_ n: Int) {
@@ -855,7 +901,7 @@ public func run_BridgedNSDictionaryEnumerate(_ n: Int) {
 public func run_BridgedNSArrayBufferAccess(_ n: Int) {
   #if _runtime(_ObjC)
   for _ in 0 ..< n {
-    for i in 0..<1000 {
+    for _ in 0..<1000 {
       let tmp = nsArray as! [NSObject]
       blackHole(tmp)
       blackHole(tmp.withContiguousStorageIfAvailable {
@@ -872,7 +918,7 @@ public func run_BridgedNSArrayRepeatedBufferAccess(_ n: Int) {
   for _ in 0 ..< n {
     let tmp = nsArray as! [NSObject]
     blackHole(tmp)
-    for i in 0..<1000 {
+    for _ in 0..<1000 {
       blackHole(tmp.withContiguousStorageIfAvailable {
         $0[0]
       })
@@ -914,3 +960,81 @@ public func run_RealNSArrayMutableCopyObjectAtIndex(_ n: Int) {
   #endif
 }
 
+@inline(__always)
+fileprivate func run_BridgedNSStringLength(_ asciiBase: Bool, _ enc: UInt, _ n: Int) {
+  let str = asciiBase ? bridgedASCIIString : bridgedUTF8String
+  for _ in 0 ..< n * 100 {
+    blackHole(str!.lengthOfBytes(using: enc))
+  }
+}
+
+@inline(never)
+public func run_BridgedNSStringLengthASCII_ASCII(_ n: Int) {
+  run_BridgedNSStringLength(true, 1 /* NSASCIIStringEncoding */, n)
+}
+
+@inline(never)
+public func run_BridgedNSStringLengthASCII_UTF8(_ n: Int) {
+  run_BridgedNSStringLength(true, 4 /* NSUTF8StringEncoding */, n)
+}
+
+@inline(never)
+public func run_BridgedNSStringLengthASCII_UTF16(_ n: Int) {
+  run_BridgedNSStringLength(true, 10 /* NSUnicodeStringEncoding */, n)
+}
+
+@inline(never)
+public func run_BridgedNSStringLengthASCII_MacRoman(_ n: Int) {
+  run_BridgedNSStringLength(true, 30 /* NSMacOSRomanStringEncoding */, n)
+}
+
+@inline(never)
+public func run_BridgedNSStringLengthUTF8_UTF8(_ n: Int) {
+  run_BridgedNSStringLength(false, 4 /* NSUTF8StringEncoding */, n)
+}
+
+@inline(never)
+public func run_BridgedNSStringLengthUTF8_UTF16(_ n: Int) {
+  run_BridgedNSStringLength(false, 10 /* NSUnicodeStringEncoding */, n)
+}
+
+@inline(__always)
+fileprivate func run_BridgedNSStringMaxLength(_ asciiBase: Bool, _ enc: UInt, _ n: Int) {
+  let str = asciiBase ? bridgedASCIIString! : bridgedUTF8String!
+  for _ in 0 ..< n * 100 {
+    for i in 0..<100 {
+      blackHole(str.maximumLengthOfBytes(using: enc))
+    }
+  }
+}
+
+@inline(never)
+public func run_BridgedNSStringMaxLengthASCII_ASCII(_ n: Int) {
+  run_BridgedNSStringMaxLength(true, 1 /* NSASCIIStringEncoding */, n)
+}
+
+@inline(never)
+public func run_BridgedNSStringMaxLengthASCII_UTF8(_ n: Int) {
+  run_BridgedNSStringMaxLength(true, 4 /* NSUTF8StringEncoding */, n)
+}
+
+@inline(never)
+public func run_BridgedNSStringMaxLengthASCII_UTF16(_ n: Int) {
+  run_BridgedNSStringMaxLength(true, 10 /* NSUnicodeStringEncoding */, n)
+}
+
+@inline(never)
+public func run_BridgedNSStringMaxLengthASCII_MacRoman(_ n: Int) {
+  run_BridgedNSStringMaxLength(true, 30 /* NSMacOSRomanStringEncoding */, n)
+}
+
+@inline(never)
+public func run_BridgedNSStringMaxLengthUTF8_UTF8(_ n: Int) {
+  run_BridgedNSStringMaxLength(false, 4 /* NSUTF8StringEncoding */, n)
+}
+
+@inline(never)
+public func run_BridgedNSStringMaxLengthUTF8_UTF16(_ n: Int) {
+  run_BridgedNSStringMaxLength(false, 10 /* NSUnicodeStringEncoding */, n)
+}
+