SideEffectAnalysis: ignore _swift_stdlib_malloc_size and _swift_stdlib_has_malloc_size runtime calls

Those runtime calls are used in the Array implementation and prevented optimizations like redundant load elimination.

Author: eeckstein

lib/SILOptimizer/Analysis/SideEffectAnalysis.cpp

@@ -498,6 +498,12 @@ bool FunctionSideEffects::summarizeCall(FullApplySite fullApply) {
     // Does the function have any @_effects?
     if (setDefinedEffects(SingleCallee))
       return true;
+      
+    if (SingleCallee->getName() == "_swift_stdlib_malloc_size" ||
+        SingleCallee->getName() == "_swift_stdlib_has_malloc_size") {
+      GlobalEffects.Reads = true;
+      return true;
+    }
   }
   return false;
 }

test/SILOptimizer/redundant_load_elim_ossa.sil

@@ -5,6 +5,7 @@ sil_stage canonical
 
 import Builtin
 import Swift
+import SwiftShims
 
 ///////////////////////
 // Type Declarations //
@@ -1348,6 +1349,29 @@ bb0(%0 : $*Int):
 }
 // CHECK-LABEL: } // end sil function 'test_rle_in_guaranteed_entry'
 
+sil shared [clang _swift_stdlib_has_malloc_size] @_swift_stdlib_has_malloc_size : $@convention(c) () -> Bool
+sil shared [clang _swift_stdlib_malloc_size] @_swift_stdlib_malloc_size : $@convention(c) (UnsafeRawPointer) -> Int
+
+// CHECK-LABEL: sil [ossa] @ignoreMallocSize :
+// CHECK:         [[VAL:%.*]] = load
+// CHECK:         [[UI:%.*]] = function_ref @use_Int
+// CHECK:         apply [[UI]]([[VAL]])
+// CHECK:         return [[VAL]]
+// CHECK-LABEL: } // end sil function 'ignoreMallocSize'
+sil [ossa] @ignoreMallocSize : $@convention(thin) (@guaranteed AB, UnsafeRawPointer) -> Int {
+bb0(%0 : @guaranteed $AB, %1 : $UnsafeRawPointer):
+  %2 = ref_element_addr %0 : $AB, #AB.value
+  %3 = load [trivial] %2 : $*Int
+  %4 = function_ref @_swift_stdlib_has_malloc_size : $@convention(c) () -> Bool
+  %5 = apply %4() : $@convention(c) () -> Bool
+  %6 = function_ref @_swift_stdlib_malloc_size : $@convention(c) (UnsafeRawPointer) -> Int
+  %7 = apply %6(%1) : $@convention(c) (UnsafeRawPointer) -> Int
+  %8 = load [trivial] %2 : $*Int
+  %9 = function_ref @use_Int : $@convention(thin) (Int) -> ()
+  apply %9(%3) : $@convention(thin) (Int) -> ()
+  return %8 : $Int
+}
+
 // Check that begin_access, end_access, strong_release, set_deallocating, and dealloc_ref don't prevent optimization.
 // CHECK-LABEL: ignore_read_write :
 // CHECK: bb0