Merge pull request #14258 from rintaro/basic-json-null
[JSONSerialization] Add ability to emit 'null' value.
diff --git a/CMakeLists.txt b/CMakeLists.txt
index f155d82..86a59a2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -300,6 +300,10 @@
"Build the standard libraries, overlays, and runtime with normal arguments at +0"
FALSE)
+option(SWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS
+ "Enable runtime function counters and expose the API."
+ FALSE)
+
#
# End of user-configurable options.
#
diff --git a/benchmark/scripts/Benchmark_RuntimeLeaksRunner.in b/benchmark/scripts/Benchmark_RuntimeLeaksRunner.in
index a8c4980..008d4ff 100644
--- a/benchmark/scripts/Benchmark_RuntimeLeaksRunner.in
+++ b/benchmark/scripts/Benchmark_RuntimeLeaksRunner.in
@@ -81,29 +81,35 @@
def prepare_input(self, name):
return {'num_samples': self.num_samples, 'num_iters': self.num_iters}
+ def run_test_inner(self, data, num_iters):
+ p = subprocess.Popen([
+ data['path'],
+ "--num-samples={}".format(data['num_samples']),
+ "--num-iters={}".format(num_iters), data['test_name']],
+ stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+ error_out = p.communicate()[1].split("\n")
+ result = p.returncode
+ if result is None:
+ raise RuntimeError("Expected one line of output")
+ if result != 0:
+ raise RuntimeError("Process segfaulted")
+ return error_out
+
def run_test(self, data, num_iters):
try:
- p = subprocess.Popen([
- data['path'],
- "--num-samples={}".format(data['num_samples']),
- "--num-iters={}".format(num_iters), data['test_name']],
- stdout=subprocess.PIPE, stderr=subprocess.PIPE)
- error_out = p.communicate()[1].split("\n")
- result = p.returncode
- if result is None:
- raise RuntimeError("Expected one line of output")
- if result != 0:
- raise RuntimeError("Process segfaulted")
- except Exception:
- sys.stderr.write("Child Process Failed! (%s,%s)\n" % (
- data['path'], data['test_name']))
+ args = [data, num_iters]
+ result = perf_test_driver.run_with_timeout(self.run_test_inner,
+ args)
+ except Exception, e:
+ sys.stderr.write("Child Process Failed! (%s,%s). Error: %s\n" % (
+ data['path'], data['test_name'], e))
sys.stderr.flush()
return None
try:
# We grab the second line since swift globals get lazily created in
# the first iteration.
- d = json.loads(error_out[1])
+ d = json.loads(result[1])
d['objc_objects'] = [x for x in d['objc_objects']
if x not in IGNORABLE_GLOBAL_OBJC_CLASSES]
d['objc_count'] = len(d['objc_objects'])
diff --git a/benchmark/scripts/perf_test_driver/perf_test_driver.py b/benchmark/scripts/perf_test_driver/perf_test_driver.py
index 89a5562..9cdafcc 100644
--- a/benchmark/scripts/perf_test_driver/perf_test_driver.py
+++ b/benchmark/scripts/perf_test_driver/perf_test_driver.py
@@ -57,6 +57,24 @@
print(fmt.format(self.get_name(), self.get_result()))
+def run_with_timeout(func, args):
+ # We timeout after 10 minutes.
+ timeout_seconds = 10 * 60
+
+ # We just use this to create a timeout since we use an older python. Once
+ # we update to use python >= 3.3, use the timeout API on communicate
+ # instead.
+ import multiprocessing.dummy
+ fakeThreadPool = multiprocessing.dummy.Pool(1)
+ try:
+ result = fakeThreadPool.apply_async(func, args=args)
+ return result.get(timeout_seconds)
+ except multiprocessing.TimeoutError:
+ fakeThreadPool.terminate()
+ raise RuntimeError("Child process aborted due to timeout. "
+ "Timeout: %s seconds" % timeout_seconds)
+
+
def _unwrap_self(args):
return type(args[0]).process_input(*args)
diff --git a/benchmark/utils/main.swift b/benchmark/utils/main.swift
index 24c86ae..e2dfeca 100644
--- a/benchmark/utils/main.swift
+++ b/benchmark/utils/main.swift
@@ -169,9 +169,9 @@
registerBenchmark(ByteSwap)
registerBenchmark(COWTree)
registerBenchmark(CString)
-registerBenchmark(CSVParsing)
-registerBenchmark(CSVParsingAlt)
-registerBenchmark(CSVParsingAltIndices)
+// registerBenchmark(CSVParsing)
+// registerBenchmark(CSVParsingAlt)
+// registerBenchmark(CSVParsingAltIndices)
registerBenchmark(Calculator)
registerBenchmark(CaptureProp)
registerBenchmark(CharacterLiteralsLarge)
diff --git a/cmake/modules/AddSwift.cmake b/cmake/modules/AddSwift.cmake
index 5d87b0f..17fea05 100644
--- a/cmake/modules/AddSwift.cmake
+++ b/cmake/modules/AddSwift.cmake
@@ -255,6 +255,10 @@
else()
list(APPEND result "-DNDEBUG")
endif()
+
+ if(SWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS)
+ list(APPEND result "-DSWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS")
+ endif()
if(CFLAGS_ANALYZE_CODE_COVERAGE)
list(APPEND result "-fprofile-instr-generate"
@@ -316,6 +320,10 @@
if (SWIFT_ENABLE_GUARANTEED_NORMAL_ARGUMENTS)
list(APPEND result "-Xfrontend" "-enable-guaranteed-normal-arguments")
endif()
+
+ if(SWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS)
+ list(APPEND result "-D" "SWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS")
+ endif()
set("${result_var_name}" "${result}" PARENT_SCOPE)
endfunction()
diff --git a/include/swift/Runtime/Casting.h b/include/swift/Runtime/Casting.h
index a49ac66..f634a07 100644
--- a/include/swift/Runtime/Casting.h
+++ b/include/swift/Runtime/Casting.h
@@ -37,13 +37,12 @@
///
/// \return true if the cast succeeded. Depending on the flags,
/// swift_dynamicCast may fail rather than return false.
-SWIFT_RT_ENTRY_VISIBILITY
+SWIFT_RUNTIME_EXPORT
bool
swift_dynamicCast(OpaqueValue *dest, OpaqueValue *src,
const Metadata *srcType,
const Metadata *targetType,
- DynamicCastFlags flags)
- SWIFT_CC(RegisterPreservingCC);
+ DynamicCastFlags flags);
/// \brief Checked dynamic cast to a Swift class type.
///
@@ -52,10 +51,9 @@
/// a Swift class type.
///
/// \returns the object if the cast succeeds, or null otherwise.
-SWIFT_RT_ENTRY_VISIBILITY
+SWIFT_RUNTIME_EXPORT
const void *
-swift_dynamicCastClass(const void *object, const ClassMetadata *targetType)
- SWIFT_CC(RegisterPreservingCC);
+swift_dynamicCastClass(const void *object, const ClassMetadata *targetType);
/// \brief Unconditional, checked dynamic cast to a Swift class type.
///
diff --git a/include/swift/Runtime/Config.h b/include/swift/Runtime/Config.h
index bff25c0..0c4eff1 100644
--- a/include/swift/Runtime/Config.h
+++ b/include/swift/Runtime/Config.h
@@ -96,14 +96,14 @@
// Annotation for specifying a calling convention of
// a runtime function. It should be used with declarations
// of runtime functions like this:
-// void runtime_function_name() SWIFT_CC(RegisterPreservingCC)
+// void runtime_function_name() SWIFT_CC(swift)
#define SWIFT_CC(CC) SWIFT_CC_##CC
-#define SWIFT_CC_preserve_most __attribute__((preserve_most))
-#define SWIFT_CC_preserve_all __attribute__((preserve_all))
+// SWIFT_CC(c) is the C calling convention.
#define SWIFT_CC_c
-// Define SWIFT_CC_swift in terms of the Swift CC for runtime functions.
+// SWIFT_CC(swift) is the Swift calling convention.
+// FIXME: the next comment is false.
// Functions outside the stdlib or runtime that include this file may be built
// with a compiler that doesn't support swiftcall; don't define these macros
// in that case so any incorrect usage is caught.
@@ -119,79 +119,10 @@
#define SWIFT_INDIRECT_RESULT
#endif
-#define SWIFT_CC_SwiftCC SWIFT_CC_swift
-
-// Map a logical calling convention (e.g. RegisterPreservingCC) to LLVM calling
-// convention.
-#define SWIFT_LLVM_CC(CC) SWIFT_LLVM_CC_##CC
-
-// Currently, RuntimeFunction.def uses the following calling conventions:
-// DefaultCC, RegisterPreservingCC.
-// If new runtime calling conventions are added later, they need to be mapped
-// here to something appropriate.
-
-// DefaultCC is usually the standard C calling convention.
-#define SWIFT_CC_DefaultCC SWIFT_CC_c
-#define SWIFT_CC_DefaultCC_IMPL SWIFT_CC_c
-#define SWIFT_LLVM_CC_DefaultCC llvm::CallingConv::C
-
-#define SWIFT_LLVM_CC_RegisterPreservingCC llvm::CallingConv::PreserveMost
-
-#define SWIFT_LLVM_CC_SwiftCC llvm::CallingConv::Swift
-
-// If defined, it indicates that runtime function wrappers
-// should be used on all platforms, even they do not support
-// the new calling convention which requires this.
-#define SWIFT_RT_USE_WRAPPERS_ALWAYS 1
-
-// If defined, it indicates that this calling convention is
-// supported by the current target.
-// TODO: Define it once the runtime calling convention support has
-// been integrated into clang and llvm.
-#define SWIFT_RT_USE_RegisterPreservingCC 0
-
-#if __has_attribute(preserve_most)
-#define SWIFT_BACKEND_SUPPORTS_RegisterPreservingCC 1
-#else
-#define SWIFT_BACKEND_SUPPORTS_RegisterPreservingCC 0
-#endif
-
-
-// RegisterPreservingCC is a dedicated runtime calling convention to be used
-// when calling the most popular runtime functions.
-#if SWIFT_RT_USE_RegisterPreservingCC && \
- SWIFT_BACKEND_SUPPORTS_RegisterPreservingCC && defined(__aarch64__)
-// Targets supporting the dedicated runtime convention should use it.
-// If a runtime function is using this calling convention, it can
-// be invoked only by means of a wrapper, which performs an indirect
-// call. Wrappers are generated by the IRGen and added to object files.
-// As a result, runtime functions are invoked only indirectly from
-// the user code.
-// This is a workaround for dynamic linking issues, where a dynamic
-// linker may clobber some of the callee-saved registers defined by
-// this new calling convention when it performs lazy binding of
-// runtime functions using this new calling convention.
-#define SWIFT_CC_RegisterPreservingCC \
- SWIFT_CC_preserve_most
-#define SWIFT_CC_RegisterPreservingCC_IMPL \
- SWIFT_CC_preserve_most
-
-// Indicate that wrappers should be used, because it is required
-// for the calling convention to get around dynamic linking issues.
-#define SWIFT_RT_USE_WRAPPERS 1
-
-#else
-
-// Targets not supporting the dedicated runtime calling convention
-// should use the standard calling convention instead.
-// No wrappers are required in this case by the calling convention.
-#define SWIFT_CC_RegisterPreservingCC SWIFT_CC_c
-#define SWIFT_CC_RegisterPreservingCC_IMPL SWIFT_CC_c
-
-#endif
-
-// The runtime implementation uses the preserve_most convention to save
-// registers spills on the hot path.
+// SWIFT_CC(PreserveMost) is used in the runtime implementation to prevent
+// register spills on the hot path.
+// It is not safe to use for external calls; the loader's lazy function
+// binding may not save all of the registers required for this convention.
#if __has_attribute(preserve_most) && \
(defined(__aarch64__) || defined(__x86_64__))
#define SWIFT_CC_PreserveMost __attribute__((preserve_most))
@@ -199,53 +130,10 @@
#define SWIFT_CC_PreserveMost
#endif
-// Generates a name of the runtime entry's implementation by
-// adding an underscore as a prefix and a suffix.
-#define SWIFT_RT_ENTRY_IMPL(Name) _##Name##_
-
-// Library internal way to invoke the implementation of a runtime entry.
-// E.g. a runtime function may be called internally via its public API
-// or via the function pointer.
-#define SWIFT_RT_ENTRY_CALL(Name) Name
-
-// Name of the symbol holding a reference to the
-// implementation of a runtime entry.
-#define SWIFT_RT_ENTRY_REF(Name) _##Name
-
-// String representation of the symbol's name.
-#define SWIFT_RT_ENTRY_REF_AS_STR(Name) "_" #Name
-
-#if defined(SWIFT_RT_USE_WRAPPERS_ALWAYS)
-#undef SWIFT_RT_USE_WRAPPERS
-#define SWIFT_RT_USE_WRAPPERS
-#endif
-
-#if defined(SWIFT_RT_USE_WRAPPERS)
-
-// Both the runtime functions and their implementation are hidden and
-// can be directly referenced only inside the runtime library.
-// User code can access these runtime entries only indirectly
-// via a global function pointer.
-// NOTE: In principle, entries may have LLVM_LIBRARY_VISIBILITY,
-// because they are never called directly from the code
-// produced by IRGen.
-// But some of the runtime entries are invoked directly from
-// the foundation. Therefore they should be visible.
-#define SWIFT_RT_ENTRY_VISIBILITY SWIFT_RUNTIME_EXPORT
-#define SWIFT_RT_ENTRY_IMPL_VISIBILITY LLVM_LIBRARY_VISIBILITY
-
-// Prefix of wrappers generated for runtime functions.
-#define SWIFT_WRAPPER_PREFIX "swift_rt_"
-
-#else
-
-// Runtime functions are exported, because it should be possible
-// to invoke them directly from the user code. But internal
-// implementations of runtime functions do not need to be exported.
-#define SWIFT_RT_ENTRY_VISIBILITY SWIFT_RUNTIME_EXPORT
-#define SWIFT_RT_ENTRY_IMPL_VISIBILITY LLVM_LIBRARY_VISIBILITY
-
-#endif
+// This is the DefaultCC value used by the compiler.
+// FIXME: the runtime's code does not honor DefaultCC
+// so changing this value is not sufficient.
+#define SWIFT_DEFAULT_LLVM_CC llvm::CallingConv::C
// These are temporary macros during the +0 cc exploration to cleanly support
// both +0 and +1 in the runtime.
diff --git a/include/swift/Runtime/Enum.h b/include/swift/Runtime/Enum.h
index 2b514ae..f7d94fb 100644
--- a/include/swift/Runtime/Enum.h
+++ b/include/swift/Runtime/Enum.h
@@ -67,12 +67,10 @@
/// \returns -1 if the payload case is inhabited. If an empty case is inhabited,
/// returns a value greater than or equal to zero and less than
/// emptyCases.
-SWIFT_RT_ENTRY_VISIBILITY
+SWIFT_RUNTIME_EXPORT
int swift_getEnumCaseSinglePayload(const OpaqueValue *value,
const Metadata *payload,
- unsigned emptyCases)
- SWIFT_CC(RegisterPreservingCC);
-
+ unsigned emptyCases);
/// \brief Store the tag value for the given case into a single-payload enum,
@@ -86,12 +84,11 @@
/// case, or a value greater than or equal to zero and less
/// than emptyCases for an empty case.
/// \param emptyCases - the number of empty cases in the enum.
-SWIFT_RT_ENTRY_VISIBILITY
+SWIFT_RUNTIME_EXPORT
void swift_storeEnumTagSinglePayload(OpaqueValue *value,
const Metadata *payload,
int whichCase,
- unsigned emptyCases)
- SWIFT_CC(RegisterPreservingCC);
+ unsigned emptyCases);
/// \brief Initialize the type metadata for a generic, multi-payload
/// enum instance.
diff --git a/include/swift/Runtime/HeapObject.h b/include/swift/Runtime/HeapObject.h
index 6a971d1..54dac0e 100644
--- a/include/swift/Runtime/HeapObject.h
+++ b/include/swift/Runtime/HeapObject.h
@@ -59,17 +59,10 @@
///
/// POSSIBILITIES: The argument order is fair game. It may be useful
/// to have a variant which guarantees zero-initialized memory.
-SWIFT_RT_ENTRY_VISIBILITY
+SWIFT_RUNTIME_EXPORT
HeapObject *swift_allocObject(HeapMetadata const *metadata,
size_t requiredSize,
- size_t requiredAlignmentMask)
- SWIFT_CC(RegisterPreservingCC);
-
-SWIFT_RUNTIME_EXPORT
-HeapObject *(*SWIFT_CC(RegisterPreservingCC) _swift_allocObject)(
- HeapMetadata const *metadata,
- size_t requiredSize,
- size_t requiredAlignmentMask);
+ size_t requiredAlignmentMask);
/// Initializes the object header of a stack allocated object.
///
@@ -168,9 +161,6 @@
SWIFT_RUNTIME_EXPORT
BoxPair::Return swift_allocBox(Metadata const *type);
-SWIFT_RUNTIME_EXPORT
-BoxPair::Return (*_swift_allocBox)(Metadata const *type);
-
/// Performs a uniqueness check on the pointer to a box structure. If the check
/// fails allocates a new box and stores the pointer in the buffer.
///
@@ -189,16 +179,13 @@
//
// An "alignment mask" is just the alignment (a power of 2) minus 1.
-SWIFT_RT_ENTRY_VISIBILITY
-void *swift_slowAlloc(size_t bytes, size_t alignMask)
- SWIFT_CC(RegisterPreservingCC);
-
+SWIFT_RUNTIME_EXPORT
+void *swift_slowAlloc(size_t bytes, size_t alignMask);
// If the caller cannot promise to zero the object during destruction,
// then call these corresponding APIs:
-SWIFT_RT_ENTRY_VISIBILITY
-void swift_slowDealloc(void *ptr, size_t bytes, size_t alignMask)
- SWIFT_CC(RegisterPreservingCC);
+SWIFT_RUNTIME_EXPORT
+void swift_slowDealloc(void *ptr, size_t bytes, size_t alignMask);
/// Atomically increments the retain count of an object.
///
@@ -216,54 +203,27 @@
/// - maybe a variant that can assume a non-null object
/// It may also prove worthwhile to have this use a custom CC
/// which preserves a larger set of registers.
-SWIFT_RT_ENTRY_VISIBILITY
-HeapObject *swift_retain(HeapObject *object)
- SWIFT_CC(RegisterPreservingCC);
+SWIFT_RUNTIME_EXPORT
+HeapObject *swift_retain(HeapObject *object);
SWIFT_RUNTIME_EXPORT
-HeapObject *(*SWIFT_CC(RegisterPreservingCC) _swift_retain)(HeapObject *object);
-
-SWIFT_RT_ENTRY_VISIBILITY
-HeapObject *swift_retain_n(HeapObject *object, uint32_t n)
- SWIFT_CC(RegisterPreservingCC);
+HeapObject *swift_retain_n(HeapObject *object, uint32_t n);
SWIFT_RUNTIME_EXPORT
-HeapObject *(*SWIFT_CC(RegisterPreservingCC)
- _swift_retain_n)(HeapObject *object, uint32_t n);
-
-SWIFT_RT_ENTRY_VISIBILITY
-HeapObject *swift_nonatomic_retain(HeapObject *object)
- SWIFT_CC(RegisterPreservingCC);
+HeapObject *swift_nonatomic_retain(HeapObject *object);
SWIFT_RUNTIME_EXPORT
-HeapObject *(*SWIFT_CC(RegisterPreservingCC)
- _swift_nonatomic_retain)(HeapObject *object);
-
-SWIFT_RT_ENTRY_VISIBILITY
-HeapObject* swift_nonatomic_retain_n(HeapObject *object, uint32_t n)
- SWIFT_CC(RegisterPreservingCC);
-
-SWIFT_RUNTIME_EXPORT
-HeapObject *(*SWIFT_CC(RegisterPreservingCC)
- _swift_nonatomic_retain_n)(HeapObject *object, uint32_t n);
+HeapObject* swift_nonatomic_retain_n(HeapObject *object, uint32_t n);
/// Atomically increments the reference count of an object, unless it has
/// already been destroyed. Returns nil if the object is dead.
-SWIFT_RT_ENTRY_VISIBILITY
-HeapObject *swift_tryRetain(HeapObject *object)
- SWIFT_CC(RegisterPreservingCC);
-
SWIFT_RUNTIME_EXPORT
-HeapObject * (* SWIFT_CC(RegisterPreservingCC) _swift_tryRetain)(HeapObject *);
+HeapObject *swift_tryRetain(HeapObject *object);
/// Returns true if an object is in the process of being deallocated.
SWIFT_RUNTIME_EXPORT
bool swift_isDeallocating(HeapObject *object);
-SWIFT_RUNTIME_EXPORT
-bool (* SWIFT_CC(RegisterPreservingCC) _swift_isDeallocating)(HeapObject *);
-
-
/// Attempts to atomically pin an object and increment its reference
/// count. Returns nil if the object was already pinned.
///
@@ -271,25 +231,21 @@
/// calling swift_unpin on the return value.
///
/// The object reference may not be nil.
-SWIFT_RT_ENTRY_VISIBILITY
-HeapObject *swift_tryPin(HeapObject *object)
- SWIFT_CC(RegisterPreservingCC);
+SWIFT_RUNTIME_EXPORT
+HeapObject *swift_tryPin(HeapObject *object);
-SWIFT_RT_ENTRY_VISIBILITY
-HeapObject *swift_nonatomic_tryPin(HeapObject *object)
- SWIFT_CC(RegisterPreservingCC);
+SWIFT_RUNTIME_EXPORT
+HeapObject *swift_nonatomic_tryPin(HeapObject *object);
/// Given that an object is pinned, atomically unpin it and decrement
/// the reference count.
///
/// The object reference may be nil (to simplify the protocol).
-SWIFT_RT_ENTRY_VISIBILITY
-void swift_unpin(HeapObject *object)
- SWIFT_CC(RegisterPreservingCC);
+SWIFT_RUNTIME_EXPORT
+void swift_unpin(HeapObject *object);
-SWIFT_RT_ENTRY_VISIBILITY
-void swift_nonatomic_unpin(HeapObject *object)
- SWIFT_CC(RegisterPreservingCC);
+SWIFT_RUNTIME_EXPORT
+void swift_nonatomic_unpin(HeapObject *object);
/// Atomically decrements the retain count of an object. If the
/// retain count reaches zero, the object is destroyed as follows:
@@ -306,32 +262,16 @@
/// - a variant that can safely use non-atomic operations
/// - maybe a variant that can assume a non-null object
/// It's unlikely that a custom CC would be beneficial here.
-SWIFT_RT_ENTRY_VISIBILITY
-void swift_release(HeapObject *object)
- SWIFT_CC(RegisterPreservingCC);
+SWIFT_RUNTIME_EXPORT
+void swift_release(HeapObject *object);
SWIFT_RUNTIME_EXPORT
-void (*SWIFT_CC(RegisterPreservingCC)
- _swift_release)(HeapObject *object);
-
-SWIFT_RT_ENTRY_VISIBILITY
-void swift_nonatomic_release(HeapObject *object)
- SWIFT_CC(RegisterPreservingCC);
-
-SWIFT_RUNTIME_EXPORT
-void (*SWIFT_CC(RegisterPreservingCC)
- _swift_nonatomic_release)(HeapObject *object);
-
+void swift_nonatomic_release(HeapObject *object);
/// Atomically decrements the retain count of an object n times. If the retain
/// count reaches zero, the object is destroyed
-SWIFT_RT_ENTRY_VISIBILITY
-void swift_release_n(HeapObject *object, uint32_t n)
- SWIFT_CC(RegisterPreservingCC);
-
SWIFT_RUNTIME_EXPORT
-void (*SWIFT_CC(RegisterPreservingCC)
- _swift_release_n)(HeapObject *object, uint32_t n);
+void swift_release_n(HeapObject *object, uint32_t n);
/// Sets the RC_DEALLOCATING_FLAG flag. This is done non-atomically.
/// The strong reference count of \p object must be 1 and no other thread may
@@ -339,13 +279,8 @@
SWIFT_RUNTIME_EXPORT
void swift_setDeallocating(HeapObject *object);
-SWIFT_RT_ENTRY_VISIBILITY
-void swift_nonatomic_release_n(HeapObject *object, uint32_t n)
- SWIFT_CC(RegisterPreservingCC);
-
SWIFT_RUNTIME_EXPORT
-void (*SWIFT_CC(RegisterPreservingCC)
- _swift_nonatomic_release_n)(HeapObject *object, uint32_t n);
+void swift_nonatomic_release_n(HeapObject *object, uint32_t n);
// Refcounting observation hooks for memory tools. Don't use these.
SWIFT_RUNTIME_EXPORT
@@ -387,21 +322,19 @@
/// Is this native Swift pointer a non-null unique or pinned reference
/// to an object?
-SWIFT_RT_ENTRY_VISIBILITY
-bool swift_isUniquelyReferencedOrPinned_native(
- const struct HeapObject *) SWIFT_CC(RegisterPreservingCC);
+SWIFT_RUNTIME_EXPORT
+bool swift_isUniquelyReferencedOrPinned_native(const struct HeapObject *);
/// Is this non-null native Swift pointer a unique reference to
/// an object?
-SWIFT_RT_ENTRY_VISIBILITY
-bool swift_isUniquelyReferenced_nonNull_native(
- const struct HeapObject *) SWIFT_CC(RegisterPreservingCC);
+SWIFT_RUNTIME_EXPORT
+bool swift_isUniquelyReferenced_nonNull_native(const struct HeapObject *);
/// Does this non-null native Swift pointer refer to an object that
/// is either uniquely referenced or pinned?
-SWIFT_RT_ENTRY_VISIBILITY
+SWIFT_RUNTIME_EXPORT
bool swift_isUniquelyReferencedOrPinned_nonNull_native(
- const struct HeapObject *) SWIFT_CC(RegisterPreservingCC);
+ const struct HeapObject *);
/// Deallocate the given memory.
///
@@ -418,10 +351,9 @@
/// POSSIBILITIES: It may be useful to have a variant which
/// requires the object to have been fully zeroed from offsets
/// sizeof(SwiftHeapObject) to allocatedSize.
-SWIFT_RT_ENTRY_VISIBILITY
+SWIFT_RUNTIME_EXPORT
void swift_deallocObject(HeapObject *object, size_t allocatedSize,
- size_t allocatedAlignMask)
- SWIFT_CC(RegisterPreservingCC);
+ size_t allocatedAlignMask);
/// Deallocate an uninitialized object with a strong reference count of +1.
///
@@ -434,10 +366,9 @@
/// \param allocatedAlignMask - the alignment requirement that was passed
/// to allocObject
///
-SWIFT_RT_ENTRY_VISIBILITY
+SWIFT_RUNTIME_EXPORT
void swift_deallocUninitializedObject(HeapObject *object, size_t allocatedSize,
- size_t allocatedAlignMask)
- SWIFT_CC(RegisterPreservingCC);
+ size_t allocatedAlignMask);
/// Deallocate the given memory.
///
@@ -545,70 +476,58 @@
};
/// Increment the unowned retain count.
-SWIFT_RT_ENTRY_VISIBILITY
-HeapObject *swift_unownedRetain(HeapObject *value)
- SWIFT_CC(RegisterPreservingCC);
+SWIFT_RUNTIME_EXPORT
+HeapObject *swift_unownedRetain(HeapObject *value);
/// Decrement the unowned retain count.
-SWIFT_RT_ENTRY_VISIBILITY
-void swift_unownedRelease(HeapObject *value)
- SWIFT_CC(RegisterPreservingCC);
+SWIFT_RUNTIME_EXPORT
+void swift_unownedRelease(HeapObject *value);
/// Increment the unowned retain count.
-SWIFT_RT_ENTRY_VISIBILITY
-void *swift_nonatomic_unownedRetain(HeapObject *value)
- SWIFT_CC(RegisterPreservingCC);
+SWIFT_RUNTIME_EXPORT
+void *swift_nonatomic_unownedRetain(HeapObject *value);
/// Decrement the unowned retain count.
-SWIFT_RT_ENTRY_VISIBILITY
-void swift_nonatomic_unownedRelease(HeapObject *value)
- SWIFT_CC(RegisterPreservingCC);
+SWIFT_RUNTIME_EXPORT
+void swift_nonatomic_unownedRelease(HeapObject *value);
/// Increment the unowned retain count by n.
-SWIFT_RT_ENTRY_VISIBILITY
-HeapObject *swift_unownedRetain_n(HeapObject *value, int n)
- SWIFT_CC(RegisterPreservingCC);
+SWIFT_RUNTIME_EXPORT
+HeapObject *swift_unownedRetain_n(HeapObject *value, int n);
/// Decrement the unowned retain count by n.
-SWIFT_RT_ENTRY_VISIBILITY
-void swift_unownedRelease_n(HeapObject *value, int n)
- SWIFT_CC(RegisterPreservingCC);
+SWIFT_RUNTIME_EXPORT
+void swift_unownedRelease_n(HeapObject *value, int n);
/// Increment the unowned retain count by n.
-SWIFT_RT_ENTRY_VISIBILITY
-HeapObject *swift_nonatomic_unownedRetain_n(HeapObject *value, int n)
- SWIFT_CC(RegisterPreservingCC);
+SWIFT_RUNTIME_EXPORT
+HeapObject *swift_nonatomic_unownedRetain_n(HeapObject *value, int n);
/// Decrement the unowned retain count by n.
-SWIFT_RT_ENTRY_VISIBILITY
-void swift_nonatomic_unownedRelease_n(HeapObject *value, int n)
- SWIFT_CC(RegisterPreservingCC);
+SWIFT_RUNTIME_EXPORT
+void swift_nonatomic_unownedRelease_n(HeapObject *value, int n);
/// Increment the strong retain count of an object, aborting if it has
/// been deallocated.
-SWIFT_RT_ENTRY_VISIBILITY
-HeapObject *swift_unownedRetainStrong(HeapObject *value)
- SWIFT_CC(RegisterPreservingCC);
+SWIFT_RUNTIME_EXPORT
+HeapObject *swift_unownedRetainStrong(HeapObject *value);
/// Increment the strong retain count of an object, aborting if it has
/// been deallocated.
-SWIFT_RT_ENTRY_VISIBILITY
-HeapObject *swift_nonatomic_unownedRetainStrong(HeapObject *value)
- SWIFT_CC(RegisterPreservingCC);
+SWIFT_RUNTIME_EXPORT
+HeapObject *swift_nonatomic_unownedRetainStrong(HeapObject *value);
/// Increment the strong retain count of an object which may have been
/// deallocated, aborting if it has been deallocated, and decrement its
/// unowned reference count.
-SWIFT_RT_ENTRY_VISIBILITY
-void swift_unownedRetainStrongAndRelease(HeapObject *value)
- SWIFT_CC(RegisterPreservingCC);
+SWIFT_RUNTIME_EXPORT
+void swift_unownedRetainStrongAndRelease(HeapObject *value);
/// Increment the strong retain count of an object which may have been
/// deallocated, aborting if it has been deallocated, and decrement its
/// unowned reference count.
-SWIFT_RT_ENTRY_VISIBILITY
-void swift_nonatomic_unownedRetainStrongAndRelease(HeapObject *value)
- SWIFT_CC(RegisterPreservingCC);
+SWIFT_RUNTIME_EXPORT
+void swift_nonatomic_unownedRetainStrongAndRelease(HeapObject *value);
/// Aborts if the object has been deallocated.
SWIFT_RUNTIME_EXPORT
@@ -766,21 +685,21 @@
/*****************************************************************************/
SWIFT_RUNTIME_EXPORT
-void *swift_bridgeObjectRetain(void *value)
- SWIFT_CC(DefaultCC);
-/// Increment the strong retain count of a bridged object by n.
-SWIFT_RUNTIME_EXPORT
-void *swift_bridgeObjectRetain_n(void *value, int n)
- SWIFT_CC(DefaultCC);
-
-SWIFT_RUNTIME_EXPORT
-void *swift_nonatomic_bridgeObjectRetain(void *value)
- SWIFT_CC(DefaultCC);
+void *swift_bridgeObjectRetain(void *value);
/// Increment the strong retain count of a bridged object by n.
SWIFT_RUNTIME_EXPORT
-void *swift_nonatomic_bridgeObjectRetain_n(void *value, int n)
- SWIFT_CC(DefaultCC);
+void *swift_bridgeObjectRetain_n(void *value, int n);
+
+
+SWIFT_RUNTIME_EXPORT
+void *swift_nonatomic_bridgeObjectRetain(void *value);
+
+
+/// Increment the strong retain count of a bridged object by n.
+SWIFT_RUNTIME_EXPORT
+void *swift_nonatomic_bridgeObjectRetain_n(void *value, int n);
+
/*****************************************************************************/
/************************ UNKNOWN REFERENCE-COUNTING *************************/
@@ -791,45 +710,39 @@
/// Increment the strong retain count of an object which might not be a native
/// Swift object.
SWIFT_RUNTIME_EXPORT
-void *swift_unknownRetain(void *value)
- SWIFT_CC(DefaultCC);
+void *swift_unknownRetain(void *value);
+
/// Increment the strong retain count of an object which might not be a native
/// Swift object by n.
SWIFT_RUNTIME_EXPORT
-void *swift_unknownRetain_n(void *value, int n)
- SWIFT_CC(DefaultCC);
+void *swift_unknownRetain_n(void *value, int n);
/// Increment the strong retain count of an object which might not be a native
/// Swift object.
SWIFT_RUNTIME_EXPORT
-void *swift_nonatomic_unknownRetain(void *value)
- SWIFT_CC(DefaultCC);
+void *swift_nonatomic_unknownRetain(void *value);
+
/// Increment the strong retain count of an object which might not be a native
/// Swift object by n.
SWIFT_RUNTIME_EXPORT
-void *swift_nonatomic_unknownRetain_n(void *value, int n)
- SWIFT_CC(DefaultCC);
+void *swift_nonatomic_unknownRetain_n(void *value, int n);
#else
-static inline void *swift_unknownRetain(void *value)
- SWIFT_CC(DefaultCC) {
+static inline void *swift_unknownRetain(void *value) {
return swift_retain(static_cast<HeapObject *>(value));
}
-static inline void *swift_unknownRetain_n(void *value, int n)
- SWIFT_CC(DefaultCC) {
+static inline void *swift_unknownRetain_n(void *value, int n) {
return swift_retain_n(static_cast<HeapObject *>(value), n);
}
-static inline void *swift_nonatomic_unknownRetain(void *value)
- SWIFT_CC(DefaultCC) {
+static inline void *swift_nonatomic_unknownRetain(void *value) {
return swift_nonatomic_retain(static_cast<HeapObject *>(value));
}
-static inline void *swift_nonatomic_unknownRetain_n(void *value, int n)
- SWIFT_CC(DefaultCC) {
+static inline void *swift_nonatomic_unknownRetain_n(void *value, int n) {
return swift_nonatomic_retain_n(static_cast<HeapObject *>(value), n);
}
@@ -837,64 +750,56 @@
#endif /* SWIFT_OBJC_INTEROP */
SWIFT_RUNTIME_EXPORT
-void swift_bridgeObjectRelease(void *value)
- SWIFT_CC(DefaultCC);
+void swift_bridgeObjectRelease(void *value);
+
/// Decrement the strong retain count of a bridged object by n.
SWIFT_RUNTIME_EXPORT
-void swift_bridgeObjectRelease_n(void *value, int n)
- SWIFT_CC(DefaultCC);
+void swift_bridgeObjectRelease_n(void *value, int n);
SWIFT_RUNTIME_EXPORT
-void swift_nonatomic_bridgeObjectRelease(void *value)
- SWIFT_CC(DefaultCC);
+void swift_nonatomic_bridgeObjectRelease(void *value);
+
/// Decrement the strong retain count of a bridged object by n.
SWIFT_RUNTIME_EXPORT
-void swift_nonatomic_bridgeObjectRelease_n(void *value, int n)
- SWIFT_CC(DefaultCC);
+void swift_nonatomic_bridgeObjectRelease_n(void *value, int n);
#if SWIFT_OBJC_INTEROP
/// Decrement the strong retain count of an object which might not be a native
/// Swift object.
SWIFT_RUNTIME_EXPORT
-void swift_unknownRelease(void *value)
- SWIFT_CC(DefaultCC);
+void swift_unknownRelease(void *value);
+
/// Decrement the strong retain count of an object which might not be a native
/// Swift object by n.
SWIFT_RUNTIME_EXPORT
-void swift_unknownRelease_n(void *value, int n)
- SWIFT_CC(DefaultCC);
+void swift_unknownRelease_n(void *value, int n);
/// Decrement the strong retain count of an object which might not be a native
/// Swift object.
SWIFT_RUNTIME_EXPORT
-void swift_nonatomic_unknownRelease(void *value)
- SWIFT_CC(DefaultCC);
+void swift_nonatomic_unknownRelease(void *value);
+
/// Decrement the strong retain count of an object which might not be a native
/// Swift object by n.
SWIFT_RUNTIME_EXPORT
-void swift_nonatomic_unknownRelease_n(void *value, int n)
- SWIFT_CC(DefaultCC);
+void swift_nonatomic_unknownRelease_n(void *value, int n);
#else
-static inline void swift_unknownRelease(void *value)
- SWIFT_CC(RegisterPreservingCC) {
+static inline void swift_unknownRelease(void *value) {
swift_release(static_cast<HeapObject *>(value));
}
-static inline void swift_unknownRelease_n(void *value, int n)
- SWIFT_CC(RegisterPreservingCC) {
+static inline void swift_unknownRelease_n(void *value, int n) {
swift_release_n(static_cast<HeapObject *>(value), n);
}
-static inline void swift_nonatomic_unknownRelease(void *value)
- SWIFT_CC(RegisterPreservingCC) {
+static inline void swift_nonatomic_unknownRelease(void *value) {
swift_nonatomic_release(static_cast<HeapObject *>(value));
}
-static inline void swift_nonatomic_unknownRelease_n(void *value, int n)
- SWIFT_CC(RegisterPreservingCC) {
+static inline void swift_nonatomic_unknownRelease_n(void *value, int n) {
swift_nonatomic_release_n(static_cast<HeapObject *>(value), n);
}
diff --git a/include/swift/Runtime/InstrumentsSupport.h b/include/swift/Runtime/InstrumentsSupport.h
index 6a0c3f9..40fe9d6 100644
--- a/include/swift/Runtime/InstrumentsSupport.h
+++ b/include/swift/Runtime/InstrumentsSupport.h
@@ -20,49 +20,41 @@
namespace swift {
+// liboainject patches the function pointers and calls the functions below.
SWIFT_RUNTIME_EXPORT
HeapObject *(*_swift_allocObject)(HeapMetadata const *metadata,
- size_t requiredSize,
- size_t requiredAlignmentMask);
-
+ size_t requiredSize,
+ size_t requiredAlignmentMask);
SWIFT_RUNTIME_EXPORT
BoxPair::Return (*_swift_allocBox)(Metadata const *type);
-
SWIFT_RUNTIME_EXPORT
HeapObject *(*_swift_retain)(HeapObject *object);
SWIFT_RUNTIME_EXPORT
HeapObject *(*_swift_retain_n)(HeapObject *object, uint32_t n);
SWIFT_RUNTIME_EXPORT
-HeapObject *(*_swift_nonatomic_retain)(HeapObject *object);
-SWIFT_RUNTIME_EXPORT
HeapObject *(*_swift_tryRetain)(HeapObject *object);
SWIFT_RUNTIME_EXPORT
-bool (*_swift_isDeallocating)(HeapObject *object);
-SWIFT_RUNTIME_EXPORT
void (*_swift_release)(HeapObject *object);
SWIFT_RUNTIME_EXPORT
void (*_swift_release_n)(HeapObject *object, uint32_t n);
SWIFT_RUNTIME_EXPORT
-void (*_swift_nonatomic_release)(HeapObject *object);
+size_t swift_retainCount(HeapObject *object);
-// liboainject on iOS 8 patches the function pointers below if present.
+// liboainject tries to patch the function pointers and call the functions below
+// Swift used to implement these but no longer does.
// Do not reuse these names unless you do what oainject expects you to do.
-typedef size_t AllocIndex;
SWIFT_RUNTIME_EXPORT
-void *(*_swift_alloc)(AllocIndex idx);
+void *(*_swift_alloc)(size_t idx);
SWIFT_RUNTIME_EXPORT
-void *(*_swift_tryAlloc)(AllocIndex idx);
+void *(*_swift_tryAlloc)(size_t idx);
SWIFT_RUNTIME_EXPORT
-void *(*_swift_slowAlloc)(size_t bytes, size_t alignMask,
- uintptr_t flags);
+void *(*_swift_slowAlloc)(size_t bytes, size_t alignMask, uintptr_t flags);
SWIFT_RUNTIME_EXPORT
-void (*_swift_dealloc)(void *ptr, AllocIndex idx);
+void (*_swift_dealloc)(void *ptr, size_t idx);
SWIFT_RUNTIME_EXPORT
void (*_swift_slowDealloc)(void *ptr, size_t bytes, size_t alignMask);
SWIFT_RUNTIME_EXPORT
-size_t _swift_indexToSize(AllocIndex idx);
-SWIFT_RUNTIME_EXPORT
-int _swift_sizeToIndex(size_t size);
+size_t _swift_indexToSize(size_t idx);
SWIFT_RUNTIME_EXPORT
void _swift_zone_init(void);
diff --git a/include/swift/Runtime/Metadata.h b/include/swift/Runtime/Metadata.h
index 5c3c85b..dc3915e 100644
--- a/include/swift/Runtime/Metadata.h
+++ b/include/swift/Runtime/Metadata.h
@@ -2759,11 +2759,10 @@
/// metadata)
/// return metadata
/// }
-SWIFT_RT_ENTRY_VISIBILITY
+SWIFT_RUNTIME_EXPORT
const Metadata *
swift_getGenericMetadata(GenericMetadata *pattern,
- const void *arguments)
- SWIFT_CC(RegisterPreservingCC);
+ const void *arguments);
// Callback to allocate a generic class metadata object.
SWIFT_RUNTIME_EXPORT
@@ -2798,12 +2797,11 @@
/// never form part of the uniquing key for the conformance, which
/// is ultimately a statement about the user model of overlapping
/// conformances.
-SWIFT_RT_ENTRY_VISIBILITY
+SWIFT_RUNTIME_EXPORT
const WitnessTable *
swift_getGenericWitnessTable(GenericWitnessTable *genericTable,
const Metadata *type,
- void * const *instantiationArgs)
- SWIFT_CC(RegisterPreservingCC);
+ void * const *instantiationArgs);
/// \brief Fetch a uniqued metadata for a function type.
SWIFT_RUNTIME_EXPORT
@@ -2844,6 +2842,10 @@
void
swift_instantiateObjCClass(const ClassMetadata *theClass);
+SWIFT_RUNTIME_EXPORT
+Class
+swift_getInitializedObjCClass(Class c);
+
/// \brief Fetch a uniqued type metadata for an ObjC class.
SWIFT_RUNTIME_EXPORT
const Metadata *
@@ -2940,13 +2942,12 @@
/// \brief Fetch a uniqued metadata for an existential type. The array
/// referenced by \c protocols will be sorted in-place.
-SWIFT_RT_ENTRY_VISIBILITY
+SWIFT_RUNTIME_EXPORT
const ExistentialTypeMetadata *
swift_getExistentialTypeMetadata(ProtocolClassConstraint classConstraint,
const Metadata *superclassConstraint,
size_t numProtocols,
- const ProtocolDescriptor * const *protocols)
- SWIFT_CC(RegisterPreservingCC);
+ const ProtocolDescriptor * const *protocols);
/// \brief Perform a copy-assignment from one existential container to another.
/// Both containers must be of the same existential type representable with the
diff --git a/include/swift/Runtime/RuntimeFnWrappersGen.h b/include/swift/Runtime/RuntimeFnWrappersGen.h
index 7814bc1..dd1355d 100644
--- a/include/swift/Runtime/RuntimeFnWrappersGen.h
+++ b/include/swift/Runtime/RuntimeFnWrappersGen.h
@@ -32,23 +32,5 @@
llvm::ArrayRef<llvm::Type*> argTypes,
llvm::ArrayRef<llvm::Attribute::AttrKind> attrs);
-/// Generate an llvm wrapper for a runtime entry with a
-/// given name, return types, argument types, attributes and a
-/// calling convention.
-///
-/// Symbol is the name of a global symbol containing the
-/// address of the runtime entry implementation.
-/// The wrapper simply invokes a corresponding entry point
-/// by means of an indirect call of the function currently
-/// referenced by the symbol.
-///
-/// Each wrapper has a hidden linkage and marked as ODR, so that
-/// a linker can merge all wrappers with the same name.
-llvm::Constant *getWrapperFn(llvm::Module &Module, llvm::Constant *&cache,
- char const *name, char const *symbol,
- llvm::CallingConv::ID cc,
- llvm::ArrayRef<llvm::Type *> retTypes,
- llvm::ArrayRef<llvm::Type *> argTypes,
- llvm::ArrayRef<llvm::Attribute::AttrKind> attrs);
} /* Namespace swift */
#endif
diff --git a/include/swift/Runtime/RuntimeFunctions.def b/include/swift/Runtime/RuntimeFunctions.def
index 18e0200..432c187 100644
--- a/include/swift/Runtime/RuntimeFunctions.def
+++ b/include/swift/Runtime/RuntimeFunctions.def
@@ -38,19 +38,7 @@
#define FUNCTION(Id, Name, CC, ReturnTys, ArgTys, Attrs) FUNCTION_ID(Id)
#endif
-/// This is a special version for runtime functions which have a global
-/// symbol containing a reference of the implementation of this runtime
-/// entry.
-/// SymbolName is the name of the global symbol
-/// Impl is the name of the function implementing this entry point.
-#ifndef FUNCTION_WITH_GLOBAL_SYMBOL_AND_IMPL
-#define FUNCTION_WITH_GLOBAL_SYMBOL_AND_IMPL(Id, Name, SymbolName, Impl, CC, \
- ReturnTys, ArgTys, Attrs) \
- FUNCTION_ID(Id)
-#endif
-
-FUNCTION_WITH_GLOBAL_SYMBOL_AND_IMPL(AllocBox, swift_allocBox,
- _swift_allocBox, _swift_allocBox_, DefaultCC,
+FUNCTION(AllocBox, swift_allocBox, C_CC,
RETURNS(RefCountedPtrTy, OpaquePtrTy),
ARGS(TypeMetadataPtrTy),
ATTRS(NoUnwind))
@@ -58,92 +46,91 @@
// BoxPair swift_makeBoxUnique(OpaqueValue *buffer, Metadata *type, size_t alignMask);
FUNCTION(MakeBoxUnique,
swift_makeBoxUnique,
- DefaultCC,
+ C_CC,
RETURNS(RefCountedPtrTy, OpaquePtrTy),
ARGS(OpaquePtrTy, TypeMetadataPtrTy, SizeTy),
ATTRS(NoUnwind))
-FUNCTION(DeallocBox, swift_deallocBox, DefaultCC,
+FUNCTION(DeallocBox, swift_deallocBox, C_CC,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind))
-FUNCTION(ProjectBox, swift_projectBox, DefaultCC,
+FUNCTION(ProjectBox, swift_projectBox, C_CC,
RETURNS(OpaquePtrTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind, ReadNone))
-FUNCTION(AllocEmptyBox, swift_allocEmptyBox, DefaultCC,
+FUNCTION(AllocEmptyBox, swift_allocEmptyBox, C_CC,
RETURNS(RefCountedPtrTy),
ARGS(),
ATTRS(NoUnwind))
// RefCounted *swift_allocObject(Metadata *type, size_t size, size_t alignMask);
-FUNCTION_WITH_GLOBAL_SYMBOL_AND_IMPL(AllocObject, swift_allocObject,
- _swift_allocObject, _swift_allocObject_, RegisterPreservingCC,
+FUNCTION(AllocObject, swift_allocObject, C_CC,
RETURNS(RefCountedPtrTy),
ARGS(TypeMetadataPtrTy, SizeTy, SizeTy),
ATTRS(NoUnwind))
// HeapObject *swift_initStackObject(HeapMetadata const *metadata,
// HeapObject *object);
-FUNCTION(InitStackObject, swift_initStackObject, DefaultCC,
+FUNCTION(InitStackObject, swift_initStackObject, C_CC,
RETURNS(RefCountedPtrTy),
ARGS(TypeMetadataPtrTy, RefCountedPtrTy),
ATTRS(NoUnwind))
// HeapObject *swift_initStaticObject(HeapMetadata const *metadata,
// HeapObject *object);
-FUNCTION(InitStaticObject, swift_initStaticObject, DefaultCC,
+FUNCTION(InitStaticObject, swift_initStaticObject, C_CC,
RETURNS(RefCountedPtrTy),
ARGS(TypeMetadataPtrTy, RefCountedPtrTy),
ATTRS(NoUnwind))
// void swift_verifyEndOfLifetime(HeapObject *object);
-FUNCTION(VerifyEndOfLifetime, swift_verifyEndOfLifetime, DefaultCC,
+FUNCTION(VerifyEndOfLifetime, swift_verifyEndOfLifetime, C_CC,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind))
// void swift_deallocObject(HeapObject *obj, size_t size, size_t alignMask);
-FUNCTION(DeallocObject, swift_deallocObject, RegisterPreservingCC,
+FUNCTION(DeallocObject, swift_deallocObject, C_CC,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy, SizeTy, SizeTy),
ATTRS(NoUnwind))
// void swift_deallocUninitializedObject(HeapObject *obj, size_t size, size_t alignMask);
FUNCTION(DeallocUninitializedObject, swift_deallocUninitializedObject,
- RegisterPreservingCC,
+ C_CC,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy, SizeTy, SizeTy),
ATTRS(NoUnwind))
// void swift_deallocClassInstance(HeapObject *obj, size_t size, size_t alignMask);
-FUNCTION(DeallocClassInstance, swift_deallocClassInstance, DefaultCC,
+FUNCTION(DeallocClassInstance, swift_deallocClassInstance, C_CC,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy, SizeTy, SizeTy),
ATTRS(NoUnwind))
// void swift_deallocPartialClassInstance(HeapObject *obj, HeapMetadata *type, size_t size, size_t alignMask);
-FUNCTION(DeallocPartialClassInstance, swift_deallocPartialClassInstance, DefaultCC,
+FUNCTION(DeallocPartialClassInstance, swift_deallocPartialClassInstance, C_CC,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy, TypeMetadataPtrTy, SizeTy, SizeTy),
ATTRS(NoUnwind))
// void *swift_slowAlloc(size_t size, size_t alignMask);
-FUNCTION(SlowAlloc, swift_slowAlloc, RegisterPreservingCC,
+FUNCTION(SlowAlloc, swift_slowAlloc, C_CC,
RETURNS(Int8PtrTy),
ARGS(SizeTy, SizeTy),
ATTRS(NoUnwind))
// void swift_slowDealloc(void *ptr, size_t size, size_t alignMask);
-FUNCTION(SlowDealloc, swift_slowDealloc, RegisterPreservingCC,
+FUNCTION(SlowDealloc, swift_slowDealloc, C_CC,
RETURNS(VoidTy),
ARGS(Int8PtrTy, SizeTy, SizeTy),
ATTRS(NoUnwind))
// void swift_willThrow(error *ptr);
-FUNCTION(WillThrow, swift_willThrow, DefaultCC,
+FUNCTION(WillThrow, swift_willThrow, C_CC,
RETURNS(VoidTy),
ARGS(ErrorPtrTy),
ATTRS(NoUnwind))
@@ -161,475 +148,465 @@
ATTRS(NoUnwind, NoReturn))
// void *swift_copyPOD(void *dest, void *src, Metadata *self);
-FUNCTION(CopyPOD, swift_copyPOD, DefaultCC,
+FUNCTION(CopyPOD, swift_copyPOD, C_CC,
RETURNS(OpaquePtrTy),
ARGS(OpaquePtrTy, OpaquePtrTy, TypeMetadataPtrTy),
ATTRS(NoUnwind))
// void *swift_retain(void *ptr);
-FUNCTION_WITH_GLOBAL_SYMBOL_AND_IMPL(NativeStrongRetain, swift_retain,
- _swift_retain, _swift_retain_, RegisterPreservingCC,
+FUNCTION(NativeStrongRetain, swift_retain, C_CC,
RETURNS(RefCountedPtrTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// void swift_release(void *ptr);
-FUNCTION_WITH_GLOBAL_SYMBOL_AND_IMPL(NativeStrongRelease, swift_release,
- _swift_release, _swift_release_, RegisterPreservingCC,
+FUNCTION(NativeStrongRelease, swift_release, C_CC,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind))
// void *swift_retain_n(void *ptr, int32_t n);
-FUNCTION_WITH_GLOBAL_SYMBOL_AND_IMPL(NativeStrongRetainN, swift_retain_n,
- _swift_retain_n, _swift_retain_n_, RegisterPreservingCC,
+FUNCTION(NativeStrongRetainN, swift_retain_n, C_CC,
RETURNS(RefCountedPtrTy),
ARGS(RefCountedPtrTy, Int32Ty),
ATTRS(NoUnwind, FirstParamReturned))
// void *swift_release_n(void *ptr, int32_t n);
-FUNCTION_WITH_GLOBAL_SYMBOL_AND_IMPL(NativeStrongReleaseN, swift_release_n,
- _swift_release_n, _swift_release_n_, RegisterPreservingCC,
+FUNCTION(NativeStrongReleaseN, swift_release_n, C_CC,
RETURNS(RefCountedPtrTy),
ARGS(RefCountedPtrTy, Int32Ty),
ATTRS(NoUnwind, FirstParamReturned))
// void swift_setDeallocating(void *ptr);
FUNCTION(NativeSetDeallocating, swift_setDeallocating,
- DefaultCC,
+ C_CC,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind))
// void *swift_nonatomic_retain_n(void *ptr, int32_t n);
-FUNCTION_WITH_GLOBAL_SYMBOL_AND_IMPL(NativeNonAtomicStrongRetainN, swift_nonatomic_retain_n,
- _swift_nonatomic_retain_n, _swift_nonatomic_retain_n_, RegisterPreservingCC,
+FUNCTION(NativeNonAtomicStrongRetainN, swift_nonatomic_retain_n, C_CC,
RETURNS(RefCountedPtrTy),
ARGS(RefCountedPtrTy, Int32Ty),
ATTRS(NoUnwind, FirstParamReturned))
// void swift_nonatomic_release_n(void *ptr, int32_t n);
-FUNCTION_WITH_GLOBAL_SYMBOL_AND_IMPL(NativeNonAtomicStrongReleaseN, swift_nonatomic_release_n,
- _swift_nonatomic_release_n, _swift_nonatomic_release_n_, RegisterPreservingCC,
+FUNCTION(NativeNonAtomicStrongReleaseN, swift_nonatomic_release_n, C_CC,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy, Int32Ty),
ATTRS(NoUnwind))
// void *swift_unknownRetain_n(void *ptr, int32_t n);
FUNCTION(UnknownRetainN, swift_unknownRetain_n,
- DefaultCC,
+ C_CC,
RETURNS(RefCountedPtrTy),
ARGS(RefCountedPtrTy, Int32Ty),
ATTRS(NoUnwind, FirstParamReturned))
// void swift_unknownRelease_n(void *ptr, int32_t n);
FUNCTION(UnknownReleaseN, swift_unknownRelease_n,
- DefaultCC,
+ C_CC,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy, Int32Ty),
ATTRS(NoUnwind))
// void *swift_nonatomic_unknownRetain_n(void *ptr, int32_t n);
FUNCTION(NonAtomicUnknownRetainN, swift_nonatomic_unknownRetain_n,
- DefaultCC,
+ C_CC,
RETURNS(RefCountedPtrTy),
ARGS(RefCountedPtrTy, Int32Ty),
ATTRS(NoUnwind, FirstParamReturned))
// void swift_nonatomic_unknownRelease_n(void *ptr, int32_t n);
FUNCTION(NonAtomicUnknownReleaseN, swift_nonatomic_unknownRelease_n,
- DefaultCC,
+ C_CC,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy, Int32Ty),
ATTRS(NoUnwind))
// void swift_bridgeObjectRetain_n(void *ptr, int32_t n);
FUNCTION(BridgeObjectRetainN, swift_bridgeObjectRetain_n,
- DefaultCC,
+ C_CC,
RETURNS(BridgeObjectPtrTy),
ARGS(BridgeObjectPtrTy, Int32Ty),
ATTRS(NoUnwind))
// void swift_bridgeObjectRelease_n(void *ptr, int32_t n);
FUNCTION(BridgeObjectReleaseN, swift_bridgeObjectRelease_n,
- DefaultCC,
+ C_CC,
RETURNS(VoidTy),
ARGS(BridgeObjectPtrTy, Int32Ty),
ATTRS(NoUnwind))
// void swift_nonatomic_bridgeObjectRetain_n(void *ptr, int32_t n);
FUNCTION(NonAtomicBridgeObjectRetainN, swift_nonatomic_bridgeObjectRetain_n,
- DefaultCC,
+ C_CC,
RETURNS(BridgeObjectPtrTy),
ARGS(BridgeObjectPtrTy, Int32Ty),
ATTRS(NoUnwind))
// void swift_nonatomic_bridgeObjectRelease_n(void *ptr, int32_t n);
FUNCTION(NonAtomicBridgeObjectReleaseN, swift_nonatomic_bridgeObjectRelease_n,
- DefaultCC,
+ C_CC,
RETURNS(VoidTy),
ARGS(BridgeObjectPtrTy, Int32Ty),
ATTRS(NoUnwind))
// void *swift_nonatomic_retain(void *ptr);
-FUNCTION_WITH_GLOBAL_SYMBOL_AND_IMPL(NativeNonAtomicStrongRetain, swift_nonatomic_retain,
- _swift_nonatomic_retain, _swift_nonatomic_retain_, RegisterPreservingCC,
+FUNCTION(NativeNonAtomicStrongRetain, swift_nonatomic_retain, C_CC,
RETURNS(RefCountedPtrTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// void *swift_tryPin(void *ptr);
-FUNCTION(NativeTryPin, swift_tryPin, RegisterPreservingCC,
+FUNCTION(NativeTryPin, swift_tryPin, C_CC,
RETURNS(RefCountedPtrTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind))
// void swift_nonatomic_release(void *ptr);
-FUNCTION_WITH_GLOBAL_SYMBOL_AND_IMPL(NativeNonAtomicStrongRelease, swift_nonatomic_release,
- _swift_nonatomic_release, _swift_nonatomic_release_, RegisterPreservingCC,
+FUNCTION(NativeNonAtomicStrongRelease, swift_nonatomic_release, C_CC,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind))
// void *swift_tryRetain(void *ptr);
-FUNCTION_WITH_GLOBAL_SYMBOL_AND_IMPL(NativeTryRetain, swift_tryRetain,
- _swift_tryRetain, _swift_tryRetain_, RegisterPreservingCC,
+FUNCTION(NativeTryRetain, swift_tryRetain, C_CC,
RETURNS(RefCountedPtrTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind))
// void swift_unpin(void *ptr);
-FUNCTION(NativeUnpin, swift_unpin, RegisterPreservingCC,
+FUNCTION(NativeUnpin, swift_unpin, C_CC,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind))
// bool swift_isDeallocating(void *ptr);
-FUNCTION_WITH_GLOBAL_SYMBOL_AND_IMPL(IsDeallocating, swift_isDeallocating,
- _swift_isDeallocating, _swift_isDeallocating_, DefaultCC,
+FUNCTION(IsDeallocating, swift_isDeallocating, C_CC,
RETURNS(Int1Ty),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind, ZExt))
// void *swift_nonatomic_tryPin(void *ptr);
-FUNCTION(NonAtomicNativeTryPin, swift_nonatomic_tryPin, RegisterPreservingCC,
+FUNCTION(NonAtomicNativeTryPin, swift_nonatomic_tryPin, C_CC,
RETURNS(RefCountedPtrTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind))
// void swift_nonatomic_unpin(void *ptr);
-FUNCTION(NonAtomicNativeUnpin, swift_nonatomic_unpin, RegisterPreservingCC,
+FUNCTION(NonAtomicNativeUnpin, swift_nonatomic_unpin, C_CC,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind))
// void *swift_unknownRetain(void *ptr);
-FUNCTION(UnknownRetain, swift_unknownRetain, DefaultCC,
+FUNCTION(UnknownRetain, swift_unknownRetain, C_CC,
RETURNS(UnknownRefCountedPtrTy),
ARGS(UnknownRefCountedPtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// void swift_unknownRelease(void *ptr);
-FUNCTION(UnknownRelease, swift_unknownRelease, DefaultCC,
+FUNCTION(UnknownRelease, swift_unknownRelease, C_CC,
RETURNS(VoidTy),
ARGS(UnknownRefCountedPtrTy),
ATTRS(NoUnwind))
// void *swift_nonatomic_unknownRetain(void *ptr);
-FUNCTION(NonAtomicUnknownRetain, swift_nonatomic_unknownRetain, DefaultCC,
+FUNCTION(NonAtomicUnknownRetain, swift_nonatomic_unknownRetain, C_CC,
RETURNS(UnknownRefCountedPtrTy),
ARGS(UnknownRefCountedPtrTy),
ATTRS(NoUnwind, FirstParamReturned))
-// void swift_unknownRelease(void *ptr);
-FUNCTION(NonAtomicUnknownRelease, swift_nonatomic_unknownRelease, DefaultCC,
+// void swift_nonatomic_unknownRelease(void *ptr);
+FUNCTION(NonAtomicUnknownRelease, swift_nonatomic_unknownRelease, C_CC,
RETURNS(VoidTy),
ARGS(UnknownRefCountedPtrTy),
ATTRS(NoUnwind))
// void *swift_bridgeObjectRetain(void *ptr);
-FUNCTION(BridgeObjectStrongRetain, swift_bridgeObjectRetain, DefaultCC,
+FUNCTION(BridgeObjectStrongRetain, swift_bridgeObjectRetain, C_CC,
RETURNS(BridgeObjectPtrTy),
ARGS(BridgeObjectPtrTy),
ATTRS(NoUnwind))
// void swift_bridgeRelease(void *ptr);
-FUNCTION(BridgeObjectStrongRelease, swift_bridgeObjectRelease, DefaultCC,
+FUNCTION(BridgeObjectStrongRelease, swift_bridgeObjectRelease, C_CC,
RETURNS(VoidTy),
ARGS(BridgeObjectPtrTy),
ATTRS(NoUnwind))
// void *swift_nonatomic_bridgeObjectRetain(void *ptr);
-FUNCTION(NonAtomicBridgeObjectStrongRetain, swift_nonatomic_bridgeObjectRetain, DefaultCC,
+FUNCTION(NonAtomicBridgeObjectStrongRetain, swift_nonatomic_bridgeObjectRetain, C_CC,
RETURNS(BridgeObjectPtrTy),
ARGS(BridgeObjectPtrTy),
ATTRS(NoUnwind))
// void swift_nonatomic_bridgeRelease(void *ptr);
-FUNCTION(NonAtomicBridgeObjectStrongRelease, swift_nonatomic_bridgeObjectRelease, DefaultCC,
+FUNCTION(NonAtomicBridgeObjectStrongRelease, swift_nonatomic_bridgeObjectRelease, C_CC,
RETURNS(VoidTy),
ARGS(BridgeObjectPtrTy),
ATTRS(NoUnwind))
// error *swift_errorRetain(error *ptr);
-FUNCTION(ErrorStrongRetain, swift_errorRetain, DefaultCC,
+FUNCTION(ErrorStrongRetain, swift_errorRetain, C_CC,
RETURNS(ErrorPtrTy),
ARGS(ErrorPtrTy),
ATTRS(NoUnwind))
// void swift_errorRelease(void *ptr);
-FUNCTION(ErrorStrongRelease, swift_errorRelease, DefaultCC,
+FUNCTION(ErrorStrongRelease, swift_errorRelease, C_CC,
RETURNS(VoidTy),
ARGS(ErrorPtrTy),
ATTRS(NoUnwind))
// void *swift_unownedRetain(void *ptr);
-FUNCTION(NativeUnownedRetain, swift_unownedRetain, RegisterPreservingCC,
+FUNCTION(NativeUnownedRetain, swift_unownedRetain, C_CC,
RETURNS(RefCountedPtrTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// void swift_unownedRelease(void *ptr);
-FUNCTION(NativeUnownedRelease, swift_unownedRelease, RegisterPreservingCC,
+FUNCTION(NativeUnownedRelease, swift_unownedRelease, C_CC,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind))
// void *swift_nonatomic_unownedRetain(void *ptr);
FUNCTION(NonAtomicNativeUnownedRetain, swift_nonatomic_unownedRetain,
- RegisterPreservingCC,
+ C_CC,
RETURNS(RefCountedPtrTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// void swift_nonatomic_unownedRelease(void *ptr);
FUNCTION(NonAtomicNativeUnownedRelease, swift_nonatomic_unownedRelease,
- RegisterPreservingCC,
+ C_CC,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind))
// void *swift_unownedRetain_n(void *ptr, int32_t n);
FUNCTION(UnownedRetainN, swift_unownedRetain_n,
- RegisterPreservingCC,
+ C_CC,
RETURNS(RefCountedPtrTy),
ARGS(RefCountedPtrTy, Int32Ty),
ATTRS(NoUnwind, FirstParamReturned))
// void swift_unownedRelease_n(void *ptr, int32_t n);
FUNCTION(UnownedReleaseN, swift_unownedRelease_n,
- RegisterPreservingCC,
+ C_CC,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy, Int32Ty),
ATTRS(NoUnwind))
// void *swift_nonatomic_unownedRetain_n(void *ptr, int32_t n);
FUNCTION(NonAtomicUnownedRetainN, swift_nonatomic_unownedRetain_n,
- RegisterPreservingCC,
+ C_CC,
RETURNS(RefCountedPtrTy),
ARGS(RefCountedPtrTy, Int32Ty),
ATTRS(NoUnwind, FirstParamReturned))
// void swift_nonatomic_unownedRelease_n(void *ptr, int32_t n);
FUNCTION(NonAtomicUnownedReleaseN, swift_nonatomic_unownedRelease_n,
- RegisterPreservingCC,
+ C_CC,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy, Int32Ty),
ATTRS(NoUnwind))
// void *swift_unownedRetainStrong(void *ptr);
-FUNCTION(NativeStrongRetainUnowned, swift_unownedRetainStrong, RegisterPreservingCC,
+FUNCTION(NativeStrongRetainUnowned, swift_unownedRetainStrong, C_CC,
RETURNS(RefCountedPtrTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// void *swift_nonatomic_unownedRetainStrong(void *ptr);
FUNCTION(NonAtomicNativeStrongRetainUnowned, swift_nonatomic_unownedRetainStrong,
- RegisterPreservingCC,
+ C_CC,
RETURNS(RefCountedPtrTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// void swift_unownedRetainStrongAndRelease(void *ptr);
FUNCTION(NativeStrongRetainAndUnownedRelease,
- swift_unownedRetainStrongAndRelease, RegisterPreservingCC,
+ swift_unownedRetainStrongAndRelease, C_CC,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind))
// void swift_nonatomic_unownedRetainStrongAndRelease(void *ptr);
FUNCTION(NonAtomicNativeStrongRetainAndUnownedRelease,
- swift_nonatomic_unownedRetainStrongAndRelease, RegisterPreservingCC,
+ swift_nonatomic_unownedRetainStrongAndRelease, C_CC,
RETURNS(VoidTy),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind))
// void swift_weakDestroy(WeakReference *object);
-FUNCTION(NativeWeakDestroy, swift_weakDestroy, DefaultCC,
+FUNCTION(NativeWeakDestroy, swift_weakDestroy, C_CC,
RETURNS(VoidTy),
ARGS(WeakReferencePtrTy),
ATTRS(NoUnwind))
// WeakReference *swift_weakInit(WeakReference *object, void *value);
-FUNCTION(NativeWeakInit, swift_weakInit, DefaultCC,
+FUNCTION(NativeWeakInit, swift_weakInit, C_CC,
RETURNS(WeakReferencePtrTy),
ARGS(WeakReferencePtrTy, RefCountedPtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// WeakReference *swift_weakAssign(WeakReference *object, void *value);
-FUNCTION(NativeWeakAssign, swift_weakAssign, DefaultCC,
+FUNCTION(NativeWeakAssign, swift_weakAssign, C_CC,
RETURNS(WeakReferencePtrTy),
ARGS(WeakReferencePtrTy, RefCountedPtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// void *swift_weakLoadStrong(WeakReference *object);
-FUNCTION(NativeWeakLoadStrong, swift_weakLoadStrong,DefaultCC,
+FUNCTION(NativeWeakLoadStrong, swift_weakLoadStrong,C_CC,
RETURNS(RefCountedPtrTy),
ARGS(WeakReferencePtrTy),
ATTRS(NoUnwind))
// void *swift_weakTakeStrong(WeakReference *object);
-FUNCTION(NativeWeakTakeStrong, swift_weakTakeStrong,DefaultCC,
+FUNCTION(NativeWeakTakeStrong, swift_weakTakeStrong,C_CC,
RETURNS(RefCountedPtrTy),
ARGS(WeakReferencePtrTy),
ATTRS(NoUnwind))
// WeakReference *swift_weakCopyInit(WeakReference *dest, WeakReference *src);
-FUNCTION(NativeWeakCopyInit, swift_weakCopyInit, DefaultCC,
+FUNCTION(NativeWeakCopyInit, swift_weakCopyInit, C_CC,
RETURNS(WeakReferencePtrTy),
ARGS(WeakReferencePtrTy, WeakReferencePtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// WeakReference *swift_weakTakeInit(WeakReference *dest, WeakReference *src);
-FUNCTION(NativeWeakTakeInit, swift_weakTakeInit, DefaultCC,
+FUNCTION(NativeWeakTakeInit, swift_weakTakeInit, C_CC,
RETURNS(WeakReferencePtrTy),
ARGS(WeakReferencePtrTy, WeakReferencePtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// WeakReference *swift_weakCopyAssign(WeakReference *dest, WeakReference *src);
-FUNCTION(NativeWeakCopyAssign, swift_weakCopyAssign, DefaultCC,
+FUNCTION(NativeWeakCopyAssign, swift_weakCopyAssign, C_CC,
RETURNS(WeakReferencePtrTy),
ARGS(WeakReferencePtrTy, WeakReferencePtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// WeakReference *swift_weakTakeAssign(WeakReference *dest, WeakReference *src);
-FUNCTION(NativeWeakTakeAssign, swift_weakTakeAssign, DefaultCC,
+FUNCTION(NativeWeakTakeAssign, swift_weakTakeAssign, C_CC,
RETURNS(WeakReferencePtrTy),
ARGS(WeakReferencePtrTy, WeakReferencePtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// void swift_unknownWeakDestroy(WeakReference *object);
-FUNCTION(UnknownWeakDestroy, swift_unknownWeakDestroy, DefaultCC,
+FUNCTION(UnknownWeakDestroy, swift_unknownWeakDestroy, C_CC,
RETURNS(VoidTy),
ARGS(WeakReferencePtrTy),
ATTRS(NoUnwind))
// void swift_unknownWeakInit(WeakReference *object, void *value);
-FUNCTION(UnknownWeakInit, swift_unknownWeakInit, DefaultCC,
+FUNCTION(UnknownWeakInit, swift_unknownWeakInit, C_CC,
RETURNS(WeakReferencePtrTy),
ARGS(WeakReferencePtrTy, UnknownRefCountedPtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// WeakReference *swift_unknownWeakAssign(WeakReference *object, void *value);
-FUNCTION(UnknownWeakAssign, swift_unknownWeakAssign, DefaultCC,
+FUNCTION(UnknownWeakAssign, swift_unknownWeakAssign, C_CC,
RETURNS(WeakReferencePtrTy),
ARGS(WeakReferencePtrTy, UnknownRefCountedPtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// void *swift_unknownWeakLoad(WeakReference *object);
-FUNCTION(UnknownWeakLoadStrong, swift_unknownWeakLoadStrong,DefaultCC,
+FUNCTION(UnknownWeakLoadStrong, swift_unknownWeakLoadStrong,C_CC,
RETURNS(UnknownRefCountedPtrTy),
ARGS(WeakReferencePtrTy),
ATTRS(NoUnwind))
// void *swift_unknownWeakTake(WeakReference *object);
-FUNCTION(UnknownWeakTakeStrong, swift_unknownWeakTakeStrong,DefaultCC,
+FUNCTION(UnknownWeakTakeStrong, swift_unknownWeakTakeStrong,C_CC,
RETURNS(UnknownRefCountedPtrTy),
ARGS(WeakReferencePtrTy),
ATTRS(NoUnwind))
// WeakReference *swift_unknownWeakCopyInit(WeakReference *dest, WeakReference *src);
-FUNCTION(UnknownWeakCopyInit, swift_unknownWeakCopyInit, DefaultCC,
+FUNCTION(UnknownWeakCopyInit, swift_unknownWeakCopyInit, C_CC,
RETURNS(WeakReferencePtrTy),
ARGS(WeakReferencePtrTy, WeakReferencePtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// void *swift_unknownWeakTakeInit(WeakReference *dest, WeakReference *src);
-FUNCTION(UnknownWeakTakeInit, swift_unknownWeakTakeInit, DefaultCC,
+FUNCTION(UnknownWeakTakeInit, swift_unknownWeakTakeInit, C_CC,
RETURNS(WeakReferencePtrTy),
ARGS(WeakReferencePtrTy, WeakReferencePtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// WeakReference *swift_unknownWeakCopyAssign(WeakReference *dest, WeakReference *src);
-FUNCTION(UnknownWeakCopyAssign, swift_unknownWeakCopyAssign, DefaultCC,
+FUNCTION(UnknownWeakCopyAssign, swift_unknownWeakCopyAssign, C_CC,
RETURNS(WeakReferencePtrTy),
ARGS(WeakReferencePtrTy, WeakReferencePtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// WeakReference *swift_unknownWeakTakeAssign(WeakReference *dest, WeakReference *src);
-FUNCTION(UnknownWeakTakeAssign, swift_unknownWeakTakeAssign, DefaultCC,
+FUNCTION(UnknownWeakTakeAssign, swift_unknownWeakTakeAssign, C_CC,
RETURNS(WeakReferencePtrTy),
ARGS(WeakReferencePtrTy, WeakReferencePtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// void swift_unknownUnownedDestroy(UnownedReference *object);
-FUNCTION(UnknownUnownedDestroy, swift_unknownUnownedDestroy, DefaultCC,
+FUNCTION(UnknownUnownedDestroy, swift_unknownUnownedDestroy, C_CC,
RETURNS(VoidTy),
ARGS(UnownedReferencePtrTy),
ATTRS(NoUnwind))
// UnownedReference *swift_unknownUnownedInit(UnownedReference *object, void *value);
-FUNCTION(UnknownUnownedInit, swift_unknownUnownedInit, DefaultCC,
+FUNCTION(UnknownUnownedInit, swift_unknownUnownedInit, C_CC,
RETURNS(UnownedReferencePtrTy),
ARGS(UnownedReferencePtrTy, UnknownRefCountedPtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// UnownedReference *swift_unknownUnownedAssign(UnownedReference *object, void *value);
-FUNCTION(UnknownUnownedAssign, swift_unknownUnownedAssign, DefaultCC,
+FUNCTION(UnknownUnownedAssign, swift_unknownUnownedAssign, C_CC,
RETURNS(UnownedReferencePtrTy),
ARGS(UnownedReferencePtrTy, UnknownRefCountedPtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// void *swift_unknownUnownedLoad(UnownedReference *object);
-FUNCTION(UnknownUnownedLoadStrong, swift_unknownUnownedLoadStrong, DefaultCC,
+FUNCTION(UnknownUnownedLoadStrong, swift_unknownUnownedLoadStrong, C_CC,
RETURNS(UnknownRefCountedPtrTy),
ARGS(UnownedReferencePtrTy),
ATTRS(NoUnwind))
// void *swift_unknownUnownedTake(UnownedReference *object);
-FUNCTION(UnknownUnownedTakeStrong, swift_unknownUnownedTakeStrong, DefaultCC,
+FUNCTION(UnknownUnownedTakeStrong, swift_unknownUnownedTakeStrong, C_CC,
RETURNS(UnknownRefCountedPtrTy),
ARGS(UnownedReferencePtrTy),
ATTRS(NoUnwind))
// UnownedReference *swift_unknownUnownedCopyInit(UnownedReference *dest, UnownedReference *src);
-FUNCTION(UnknownUnownedCopyInit, swift_unknownUnownedCopyInit, DefaultCC,
+FUNCTION(UnknownUnownedCopyInit, swift_unknownUnownedCopyInit, C_CC,
RETURNS(UnownedReferencePtrTy),
ARGS(UnownedReferencePtrTy, UnownedReferencePtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// UnownedReference *swift_unknownUnownedTakeInit(UnownedReference *dest, UnownedReference *src);
-FUNCTION(UnknownUnownedTakeInit, swift_unknownUnownedTakeInit, DefaultCC,
+FUNCTION(UnknownUnownedTakeInit, swift_unknownUnownedTakeInit, C_CC,
RETURNS(UnownedReferencePtrTy),
ARGS(UnownedReferencePtrTy, UnownedReferencePtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// UnownedReference *swift_unknownUnownedCopyAssign(UnownedReference *dest, UnownedReference *src);
-FUNCTION(UnknownUnownedCopyAssign, swift_unknownUnownedCopyAssign, DefaultCC,
+FUNCTION(UnknownUnownedCopyAssign, swift_unknownUnownedCopyAssign, C_CC,
RETURNS(UnownedReferencePtrTy),
ARGS(UnownedReferencePtrTy, UnownedReferencePtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// UnownedReference *swift_unknownUnownedTakeAssign(UnownedReference *dest, UnownedReference *src);
-FUNCTION(UnknownUnownedTakeAssign, swift_unknownUnownedTakeAssign, DefaultCC,
+FUNCTION(UnknownUnownedTakeAssign, swift_unknownUnownedTakeAssign, C_CC,
RETURNS(UnownedReferencePtrTy),
ARGS(UnownedReferencePtrTy, UnownedReferencePtrTy),
ATTRS(NoUnwind, FirstParamReturned))
// bool swift_isUniquelyReferencedNonObjC(const void *);
FUNCTION(IsUniquelyReferencedNonObjC, swift_isUniquelyReferencedNonObjC,
- DefaultCC,
+ C_CC,
RETURNS(Int1Ty),
ARGS(UnknownRefCountedPtrTy),
ATTRS(NoUnwind, ZExt))
@@ -637,7 +614,7 @@
// bool swift_isUniquelyReferencedNonObjC_nonNull(const void *);
FUNCTION(IsUniquelyReferencedNonObjC_nonNull,
swift_isUniquelyReferencedNonObjC_nonNull,
- DefaultCC,
+ C_CC,
RETURNS(Int1Ty),
ARGS(UnknownRefCountedPtrTy),
ATTRS(NoUnwind, ZExt))
@@ -645,7 +622,7 @@
// bool swift_isUniquelyReferencedOrPinnedNonObjC_nonNull(const void *);
FUNCTION(IsUniquelyReferencedOrPinnedNonObjC_nonNull,
swift_isUniquelyReferencedOrPinnedNonObjC_nonNull,
- DefaultCC,
+ C_CC,
RETURNS(Int1Ty),
ARGS(UnknownRefCountedPtrTy),
ATTRS(NoUnwind, ZExt))
@@ -654,7 +631,7 @@
// uintptr_t bits);
FUNCTION(IsUniquelyReferencedNonObjC_nonNull_bridgeObject,
swift_isUniquelyReferencedNonObjC_nonNull_bridgeObject,
- DefaultCC,
+ C_CC,
RETURNS(Int1Ty),
ARGS(BridgeObjectPtrTy),
ATTRS(NoUnwind, ZExt))
@@ -663,14 +640,14 @@
// uintptr_t bits);
FUNCTION(IsUniquelyReferencedOrPinnedNonObjC_nonNull_bridgeObject,
swift_isUniquelyReferencedOrPinnedNonObjC_nonNull_bridgeObject,
- DefaultCC,
+ C_CC,
RETURNS(Int1Ty),
ARGS(BridgeObjectPtrTy),
ATTRS(NoUnwind, ZExt))
// bool swift_isUniquelyReferenced_native(const struct HeapObject *);
FUNCTION(IsUniquelyReferenced_native, swift_isUniquelyReferenced_native,
- DefaultCC,
+ C_CC,
RETURNS(Int1Ty),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind, ZExt))
@@ -678,7 +655,7 @@
// bool swift_isUniquelyReferencedOrPinned_native(const struct HeapObject *);
FUNCTION(IsUniquelyReferencedOrPinned_native,
swift_isUniquelyReferencedOrPinned_native,
- RegisterPreservingCC,
+ C_CC,
RETURNS(Int1Ty),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind, ZExt))
@@ -686,7 +663,7 @@
// bool swift_isUniquelyReferenced_nonNull_native(const struct HeapObject *);
FUNCTION(IsUniquelyReferenced_nonNull_native,
swift_isUniquelyReferenced_nonNull_native,
- RegisterPreservingCC,
+ C_CC,
RETURNS(Int1Ty),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind, ZExt))
@@ -695,66 +672,66 @@
// const struct HeapObject *);
FUNCTION(IsUniquelyReferencedOrPinned_nonNull_native,
swift_isUniquelyReferencedOrPinned_nonNull_native,
- RegisterPreservingCC,
+ C_CC,
RETURNS(Int1Ty),
ARGS(RefCountedPtrTy),
ATTRS(NoUnwind, ZExt))
// void swift_arrayInitWithCopy(opaque*, opaque*, size_t, type*);
-FUNCTION(ArrayInitWithCopy, swift_arrayInitWithCopy, DefaultCC,
+FUNCTION(ArrayInitWithCopy, swift_arrayInitWithCopy, C_CC,
RETURNS(VoidTy),
ARGS(OpaquePtrTy, OpaquePtrTy, SizeTy, TypeMetadataPtrTy),
ATTRS(NoUnwind))
// void swift_arrayInitWithTakeNoAlias(opaque*, opaque*, size_t, type*);
-FUNCTION(ArrayInitWithTakeNoAlias, swift_arrayInitWithTakeNoAlias, DefaultCC,
+FUNCTION(ArrayInitWithTakeNoAlias, swift_arrayInitWithTakeNoAlias, C_CC,
RETURNS(VoidTy),
ARGS(OpaquePtrTy, OpaquePtrTy, SizeTy, TypeMetadataPtrTy),
ATTRS(NoUnwind))
// void swift_arrayInitWithTakeFrontToBack(opaque*, opaque*, size_t, type*);
FUNCTION(ArrayInitWithTakeFrontToBack, swift_arrayInitWithTakeFrontToBack,
- DefaultCC,
+ C_CC,
RETURNS(VoidTy),
ARGS(OpaquePtrTy, OpaquePtrTy, SizeTy, TypeMetadataPtrTy),
ATTRS(NoUnwind))
// void swift_arrayInitWithTakeBackToFront(opaque*, opaque*, size_t, type*);
FUNCTION(ArrayInitWithTakeBackToFront, swift_arrayInitWithTakeBackToFront,
- DefaultCC,
+ C_CC,
RETURNS(VoidTy),
ARGS(OpaquePtrTy, OpaquePtrTy, SizeTy, TypeMetadataPtrTy),
ATTRS(NoUnwind))
// void swift_arrayAssignWithCopyNoAlias(opaque*, opaque*, size_t, type*);
FUNCTION(ArrayAssignWithCopyNoAlias, swift_arrayAssignWithCopyNoAlias,
- DefaultCC,
+ C_CC,
RETURNS(VoidTy),
ARGS(OpaquePtrTy, OpaquePtrTy, SizeTy, TypeMetadataPtrTy),
ATTRS(NoUnwind))
// void swift_arrayAssignWithCopyFrontToBack(opaque*, opaque*, size_t, type*);
FUNCTION(ArrayAssignWithCopyFrontToBack, swift_arrayAssignWithCopyFrontToBack,
- DefaultCC,
+ C_CC,
RETURNS(VoidTy),
ARGS(OpaquePtrTy, OpaquePtrTy, SizeTy, TypeMetadataPtrTy),
ATTRS(NoUnwind))
// void swift_arrayAssignWithCopyBackToFront(opaque*, opaque*, size_t, type*);
FUNCTION(ArrayAssignWithCopyBackToFront, swift_arrayAssignWithCopyBackToFront,
- DefaultCC,
+ C_CC,
RETURNS(VoidTy),
ARGS(OpaquePtrTy, OpaquePtrTy, SizeTy, TypeMetadataPtrTy),
ATTRS(NoUnwind))
// void swift_arrayAssignWithTake(opaque*, opaque*, size_t, type*);
-FUNCTION(ArrayAssignWithTake, swift_arrayAssignWithTake, DefaultCC,
+FUNCTION(ArrayAssignWithTake, swift_arrayAssignWithTake, C_CC,
RETURNS(VoidTy),
ARGS(OpaquePtrTy, OpaquePtrTy, SizeTy, TypeMetadataPtrTy),
ATTRS(NoUnwind))
// void swift_arrayDestroy(opaque*, size_t, type*);
-FUNCTION(ArrayDestroy, swift_arrayDestroy, DefaultCC,
+FUNCTION(ArrayDestroy, swift_arrayDestroy, C_CC,
RETURNS(VoidTy),
ARGS(OpaquePtrTy, SizeTy, TypeMetadataPtrTy),
ATTRS(NoUnwind))
@@ -763,7 +740,7 @@
// const Metadata **parameters,
// const uint32_t *parameterFlags,
// const Metadata *result);
-FUNCTION(GetFunctionMetadata, swift_getFunctionTypeMetadata, DefaultCC,
+FUNCTION(GetFunctionMetadata, swift_getFunctionTypeMetadata, C_CC,
RETURNS(TypeMetadataPtrTy),
ARGS(SizeTy,
TypeMetadataPtrTy->getPointerTo(0),
@@ -773,7 +750,7 @@
// Metadata *swift_getFunctionTypeMetadata0(unsigned long flags,
// const Metadata *resultMetadata);
-FUNCTION(GetFunctionMetadata0, swift_getFunctionTypeMetadata0, DefaultCC,
+FUNCTION(GetFunctionMetadata0, swift_getFunctionTypeMetadata0, C_CC,
RETURNS(TypeMetadataPtrTy),
ARGS(SizeTy, TypeMetadataPtrTy),
ATTRS(NoUnwind, ReadNone))
@@ -781,7 +758,7 @@
// Metadata *swift_getFunctionTypeMetadata1(unsigned long flags,
// const Metadata *arg0,
// const Metadata *resultMetadata);
-FUNCTION(GetFunctionMetadata1, swift_getFunctionTypeMetadata1, DefaultCC,
+FUNCTION(GetFunctionMetadata1, swift_getFunctionTypeMetadata1, C_CC,
RETURNS(TypeMetadataPtrTy),
ARGS(SizeTy, TypeMetadataPtrTy, TypeMetadataPtrTy),
ATTRS(NoUnwind, ReadNone))
@@ -791,7 +768,7 @@
// const Metadata *arg1,
// const Metadata *resultMetadata);
FUNCTION(GetFunctionMetadata2, swift_getFunctionTypeMetadata2,
- DefaultCC,
+ C_CC,
RETURNS(TypeMetadataPtrTy),
ARGS(SizeTy, TypeMetadataPtrTy, TypeMetadataPtrTy, TypeMetadataPtrTy),
ATTRS(NoUnwind, ReadNone))
@@ -802,21 +779,21 @@
// const Metadata *arg2,
// const Metadata *resultMetadata);
FUNCTION(GetFunctionMetadata3, swift_getFunctionTypeMetadata3,
- DefaultCC,
+ C_CC,
RETURNS(TypeMetadataPtrTy),
ARGS(SizeTy, TypeMetadataPtrTy, TypeMetadataPtrTy, TypeMetadataPtrTy,
TypeMetadataPtrTy),
ATTRS(NoUnwind, ReadNone))
// Metadata *swift_getForeignTypeMetadata(Metadata *nonUnique);
-FUNCTION(GetForeignTypeMetadata, swift_getForeignTypeMetadata, DefaultCC,
+FUNCTION(GetForeignTypeMetadata, swift_getForeignTypeMetadata, C_CC,
RETURNS(TypeMetadataPtrTy),
ARGS(TypeMetadataPtrTy),
ATTRS(NoUnwind, ReadNone)) // only writes to runtime-private fields
// Metadata *swift_getGenericMetadata(GenericMetadata *pattern,
// const void *arguments);
-FUNCTION(GetGenericMetadata, swift_getGenericMetadata, RegisterPreservingCC,
+FUNCTION(GetGenericMetadata, swift_getGenericMetadata, C_CC,
RETURNS(TypeMetadataPtrTy),
ARGS(TypeMetadataPatternPtrTy, Int8PtrTy),
ATTRS(NoUnwind, ReadOnly))
@@ -826,14 +803,14 @@
// objc_class *superclass,
// size_t numImmediateMembers);
FUNCTION(AllocateGenericClassMetadata, swift_allocateGenericClassMetadata,
- DefaultCC, RETURNS(TypeMetadataPtrTy),
+ C_CC, RETURNS(TypeMetadataPtrTy),
ARGS(TypeMetadataPatternPtrTy, Int8PtrPtrTy, ObjCClassPtrTy, SizeTy),
ATTRS(NoUnwind))
// Metadata *swift_allocateGenericValueMetadata(GenericMetadata *pattern,
// const void * const *arguments);
FUNCTION(AllocateGenericValueMetadata, swift_allocateGenericValueMetadata,
- DefaultCC, RETURNS(TypeMetadataPtrTy),
+ C_CC, RETURNS(TypeMetadataPtrTy),
ARGS(TypeMetadataPatternPtrTy, Int8PtrPtrTy),
ATTRS(NoUnwind))
@@ -841,7 +818,7 @@
// swift_getGenericWitnessTable(GenericProtocolWitnessTable *genericTable,
// const Metadata *type,
// void * const *instantiationArgs);
-FUNCTION(GetGenericWitnessTable, swift_getGenericWitnessTable, RegisterPreservingCC,
+FUNCTION(GetGenericWitnessTable, swift_getGenericWitnessTable, C_CC,
RETURNS(WitnessTablePtrTy),
ARGS(getGenericWitnessTableCacheTy()->getPointerTo(),
TypeMetadataPtrTy,
@@ -849,26 +826,26 @@
ATTRS(NoUnwind, ReadOnly))
// Metadata *swift_getMetatypeMetadata(Metadata *instanceTy);
-FUNCTION(GetMetatypeMetadata, swift_getMetatypeMetadata, DefaultCC,
+FUNCTION(GetMetatypeMetadata, swift_getMetatypeMetadata, C_CC,
RETURNS(TypeMetadataPtrTy),
ARGS(TypeMetadataPtrTy),
ATTRS(NoUnwind, ReadNone))
// Metadata *swift_getExistentialMetatypeMetadata(Metadata *instanceTy);
FUNCTION(GetExistentialMetatypeMetadata,
- swift_getExistentialMetatypeMetadata, DefaultCC,
+ swift_getExistentialMetatypeMetadata, C_CC,
RETURNS(TypeMetadataPtrTy),
ARGS(TypeMetadataPtrTy),
ATTRS(NoUnwind, ReadNone))
// Metadata *swift_getObjCClassMetadata(objc_class *theClass);
-FUNCTION(GetObjCClassMetadata, swift_getObjCClassMetadata, DefaultCC,
+FUNCTION(GetObjCClassMetadata, swift_getObjCClassMetadata, C_CC,
RETURNS(TypeMetadataPtrTy),
ARGS(ObjCClassPtrTy),
ATTRS(NoUnwind, ReadNone))
// Metadata *swift_getObjCClassFromMetadata(objc_class *theClass);
-FUNCTION(GetObjCClassFromMetadata, swift_getObjCClassFromMetadata, DefaultCC,
+FUNCTION(GetObjCClassFromMetadata, swift_getObjCClassFromMetadata, C_CC,
RETURNS(ObjCClassPtrTy),
ARGS(TypeMetadataPtrTy),
ATTRS(NoUnwind, ReadNone))
@@ -877,7 +854,7 @@
// Metadata * const *elts,
// const char *labels,
// value_witness_table_t *proposed);
-FUNCTION(GetTupleMetadata, swift_getTupleTypeMetadata, DefaultCC,
+FUNCTION(GetTupleMetadata, swift_getTupleTypeMetadata, C_CC,
RETURNS(TypeMetadataPtrTy),
ARGS(SizeTy, TypeMetadataPtrTy->getPointerTo(0),
Int8PtrTy, WitnessTablePtrTy),
@@ -886,7 +863,7 @@
// Metadata *swift_getTupleTypeMetadata2(Metadata *elt0, Metadata *elt1,
// const char *labels,
// value_witness_table_t *proposed);
-FUNCTION(GetTupleMetadata2, swift_getTupleTypeMetadata2, DefaultCC,
+FUNCTION(GetTupleMetadata2, swift_getTupleTypeMetadata2, C_CC,
RETURNS(TypeMetadataPtrTy),
ARGS(TypeMetadataPtrTy, TypeMetadataPtrTy,
Int8PtrTy, WitnessTablePtrTy),
@@ -895,7 +872,7 @@
// Metadata *swift_getTupleTypeMetadata3(Metadata *elt0, Metadata *elt1,
// Metadata *elt2, const char *labels,
// value_witness_table_t *proposed);
-FUNCTION(GetTupleMetadata3, swift_getTupleTypeMetadata3, DefaultCC,
+FUNCTION(GetTupleMetadata3, swift_getTupleTypeMetadata3, C_CC,
RETURNS(TypeMetadataPtrTy),
ARGS(TypeMetadataPtrTy, TypeMetadataPtrTy, TypeMetadataPtrTy,
Int8PtrTy, WitnessTablePtrTy),
@@ -909,7 +886,7 @@
//
// Note: ProtocolClassConstraint::Class is 0, ::Any is 1.
FUNCTION(GetExistentialMetadata,
- swift_getExistentialTypeMetadata, RegisterPreservingCC,
+ swift_getExistentialTypeMetadata, C_CC,
RETURNS(TypeMetadataPtrTy),
ARGS(Int1Ty, TypeMetadataPtrTy, SizeTy,
ProtocolDescriptorPtrTy->getPointerTo()),
@@ -919,7 +896,7 @@
// size_t templateSize,
// size_t numImmediateMembers);
FUNCTION(RelocateClassMetadata,
- swift_relocateClassMetadata, DefaultCC,
+ swift_relocateClassMetadata, C_CC,
RETURNS(TypeMetadataPtrTy),
ARGS(TypeMetadataPtrTy, SizeTy, SizeTy),
ATTRS(NoUnwind))
@@ -930,7 +907,7 @@
// TypeLayout * const *fieldTypes,
// size_t *fieldOffsets);
FUNCTION(InitClassMetadataUniversal,
- swift_initClassMetadata_UniversalStrategy, DefaultCC,
+ swift_initClassMetadata_UniversalStrategy, C_CC,
RETURNS(VoidTy),
ARGS(TypeMetadataPtrTy, SizeTy,
Int8PtrPtrTy->getPointerTo(),
@@ -943,7 +920,7 @@
// TypeLayout * const *fieldTypes,
// size_t *fieldOffsets);
FUNCTION(InitStructMetadata,
- swift_initStructMetadata, DefaultCC,
+ swift_initStructMetadata, C_CC,
RETURNS(VoidTy),
ARGS(TypeMetadataPtrTy, SizeTy, SizeTy, Int8PtrPtrTy->getPointerTo(0),
SizeTy->getPointerTo()),
@@ -954,7 +931,7 @@
// TypeLayout *payload);
FUNCTION(InitEnumMetadataSingleCase,
swift_initEnumMetadataSingleCase,
- DefaultCC,
+ C_CC,
RETURNS(VoidTy),
ARGS(TypeMetadataPtrTy, SizeTy, Int8PtrPtrTy),
ATTRS(NoUnwind))
@@ -965,7 +942,7 @@
// unsigned num_empty_cases);
FUNCTION(InitEnumMetadataSinglePayload,
swift_initEnumMetadataSinglePayload,
- DefaultCC,
+ C_CC,
RETURNS(VoidTy),
ARGS(TypeMetadataPtrTy, SizeTy, Int8PtrPtrTy, Int32Ty),
ATTRS(NoUnwind))
@@ -975,7 +952,7 @@
// TypeLayout * const *payloadTypes);
FUNCTION(InitEnumMetadataMultiPayload,
swift_initEnumMetadataMultiPayload,
- DefaultCC,
+ C_CC,
RETURNS(VoidTy),
ARGS(TypeMetadataPtrTy, SizeTy, SizeTy, Int8PtrPtrTy->getPointerTo(0)),
ATTRS(NoUnwind))
@@ -984,7 +961,7 @@
// unsigned num_empty_cases);
FUNCTION(GetEnumCaseSinglePayload,
swift_getEnumCaseSinglePayload,
- RegisterPreservingCC,
+ C_CC,
RETURNS(Int32Ty),
ARGS(OpaquePtrTy, TypeMetadataPtrTy, Int32Ty),
ATTRS(NoUnwind, ReadOnly))
@@ -992,7 +969,7 @@
// int swift_getEnumCaseMultiPayload(opaque_t *obj, Metadata *enumTy);
FUNCTION(GetEnumCaseMultiPayload,
swift_getEnumCaseMultiPayload,
- DefaultCC,
+ C_CC,
RETURNS(Int32Ty),
ARGS(OpaquePtrTy, TypeMetadataPtrTy),
ATTRS(NoUnwind, ReadOnly))
@@ -1002,7 +979,7 @@
// unsigned num_empty_cases);
FUNCTION(StoreEnumTagSinglePayload,
swift_storeEnumTagSinglePayload,
- RegisterPreservingCC,
+ C_CC,
RETURNS(VoidTy),
ARGS(OpaquePtrTy, TypeMetadataPtrTy, Int32Ty, Int32Ty),
ATTRS(NoUnwind))
@@ -1011,7 +988,7 @@
// int case_index);
FUNCTION(StoreEnumTagMultiPayload,
swift_storeEnumTagMultiPayload,
- DefaultCC,
+ C_CC,
RETURNS(VoidTy),
ARGS(OpaquePtrTy, TypeMetadataPtrTy, Int32Ty),
ATTRS(NoUnwind))
@@ -1038,85 +1015,85 @@
ATTRS(NoUnwind, ReadNone))
// Metadata *swift_getObjectType(id object);
-FUNCTION(GetObjectType, swift_getObjectType, DefaultCC,
+FUNCTION(GetObjectType, swift_getObjectType, C_CC,
RETURNS(TypeMetadataPtrTy),
ARGS(ObjCPtrTy),
ATTRS(NoUnwind, ReadOnly))
// Metadata *swift_getDynamicType(opaque_t *obj, Metadata *self);
-FUNCTION(GetDynamicType, swift_getDynamicType, DefaultCC,
+FUNCTION(GetDynamicType, swift_getDynamicType, C_CC,
RETURNS(TypeMetadataPtrTy),
ARGS(OpaquePtrTy, TypeMetadataPtrTy, Int1Ty),
ATTRS(NoUnwind, ReadOnly))
// void *swift_dynamicCastClass(void*, void*);
-FUNCTION(DynamicCastClass, swift_dynamicCastClass, RegisterPreservingCC,
+FUNCTION(DynamicCastClass, swift_dynamicCastClass, C_CC,
RETURNS(Int8PtrTy),
ARGS(Int8PtrTy, Int8PtrTy),
ATTRS(NoUnwind, ReadOnly))
// void *swift_dynamicCastClassUnconditional(void*, void*);
FUNCTION(DynamicCastClassUnconditional, swift_dynamicCastClassUnconditional,
- DefaultCC,
+ C_CC,
RETURNS(Int8PtrTy),
ARGS(Int8PtrTy, Int8PtrTy),
ATTRS(NoUnwind, ReadOnly))
// void *swift_dynamicCastObjCClass(void*, void*);
-FUNCTION(DynamicCastObjCClass, swift_dynamicCastObjCClass, DefaultCC,
+FUNCTION(DynamicCastObjCClass, swift_dynamicCastObjCClass, C_CC,
RETURNS(Int8PtrTy),
ARGS(Int8PtrTy, Int8PtrTy),
ATTRS(NoUnwind, ReadOnly))
// void *swift_dynamicCastObjCClassUnconditional(void*, void*);
FUNCTION(DynamicCastObjCClassUnconditional,
- swift_dynamicCastObjCClassUnconditional, DefaultCC,
+ swift_dynamicCastObjCClassUnconditional, C_CC,
RETURNS(Int8PtrTy),
ARGS(Int8PtrTy, Int8PtrTy),
ATTRS(NoUnwind, ReadOnly))
// void *swift_dynamicCastUnknownClass(void*, void*);
-FUNCTION(DynamicCastUnknownClass, swift_dynamicCastUnknownClass, DefaultCC,
+FUNCTION(DynamicCastUnknownClass, swift_dynamicCastUnknownClass, C_CC,
RETURNS(Int8PtrTy),
ARGS(Int8PtrTy, Int8PtrTy),
ATTRS(NoUnwind, ReadOnly))
// void *swift_dynamicCastUnknownClassUnconditional(void*, void*);
FUNCTION(DynamicCastUnknownClassUnconditional,
- swift_dynamicCastUnknownClassUnconditional, DefaultCC,
+ swift_dynamicCastUnknownClassUnconditional, C_CC,
RETURNS(Int8PtrTy),
ARGS(Int8PtrTy, Int8PtrTy),
ATTRS(NoUnwind, ReadOnly))
// type *swift_dynamicCastMetatype(type*, type*);
-FUNCTION(DynamicCastMetatype, swift_dynamicCastMetatype, DefaultCC,
+FUNCTION(DynamicCastMetatype, swift_dynamicCastMetatype, C_CC,
RETURNS(TypeMetadataPtrTy),
ARGS(TypeMetadataPtrTy, TypeMetadataPtrTy),
ATTRS(NoUnwind, ReadOnly))
// type *swift_dynamicCastMetatypeUnconditional(type*, type*);
FUNCTION(DynamicCastMetatypeUnconditional,
- swift_dynamicCastMetatypeUnconditional, DefaultCC,
+ swift_dynamicCastMetatypeUnconditional, C_CC,
RETURNS(TypeMetadataPtrTy),
ARGS(TypeMetadataPtrTy, TypeMetadataPtrTy),
ATTRS(NoUnwind, ReadOnly))
// objc_class *swift_dynamicCastObjCClassMetatype(objc_class*, objc_class*);
FUNCTION(DynamicCastObjCClassMetatype, swift_dynamicCastObjCClassMetatype,
- DefaultCC,
+ C_CC,
RETURNS(ObjCClassPtrTy),
ARGS(ObjCClassPtrTy, ObjCClassPtrTy),
ATTRS(NoUnwind, ReadOnly))
// objc_class *swift_dynamicCastObjCClassMetatypeUnconditional(objc_class*, objc_class*);
FUNCTION(DynamicCastObjCClassMetatypeUnconditional,
- swift_dynamicCastObjCClassMetatypeUnconditional, DefaultCC,
+ swift_dynamicCastObjCClassMetatypeUnconditional, C_CC,
RETURNS(ObjCClassPtrTy),
ARGS(ObjCClassPtrTy, ObjCClassPtrTy),
ATTRS(NoUnwind, ReadOnly))
// bool swift_dynamicCast(opaque*, opaque*, type*, type*, size_t);
-FUNCTION(DynamicCast, swift_dynamicCast, RegisterPreservingCC,
+FUNCTION(DynamicCast, swift_dynamicCast, C_CC,
RETURNS(Int1Ty),
ARGS(OpaquePtrTy, OpaquePtrTy, TypeMetadataPtrTy, TypeMetadataPtrTy,
SizeTy),
@@ -1126,7 +1103,7 @@
// size_t numProtocols,
// Protocol * const *protocols);
FUNCTION(DynamicCastTypeToObjCProtocolUnconditional,
- swift_dynamicCastTypeToObjCProtocolUnconditional, DefaultCC,
+ swift_dynamicCastTypeToObjCProtocolUnconditional, C_CC,
RETURNS(TypeMetadataPtrTy),
ARGS(TypeMetadataPtrTy, SizeTy, Int8PtrPtrTy),
ATTRS(NoUnwind))
@@ -1135,7 +1112,7 @@
// size_t numProtocols,
// Protocol * const *protocols);
FUNCTION(DynamicCastTypeToObjCProtocolConditional,
- swift_dynamicCastTypeToObjCProtocolConditional, DefaultCC,
+ swift_dynamicCastTypeToObjCProtocolConditional, C_CC,
RETURNS(TypeMetadataPtrTy),
ARGS(TypeMetadataPtrTy, SizeTy, Int8PtrPtrTy),
ATTRS(NoUnwind))
@@ -1144,7 +1121,7 @@
// size_t numProtocols,
// Protocol * const *protocols);
FUNCTION(DynamicCastObjCProtocolUnconditional,
- swift_dynamicCastObjCProtocolUnconditional, DefaultCC,
+ swift_dynamicCastObjCProtocolUnconditional, C_CC,
RETURNS(ObjCPtrTy),
ARGS(ObjCPtrTy, SizeTy, Int8PtrPtrTy),
ATTRS(NoUnwind))
@@ -1153,42 +1130,42 @@
// size_t numProtocols,
// Protocol * const *protocols);
FUNCTION(DynamicCastObjCProtocolConditional,
- swift_dynamicCastObjCProtocolConditional, DefaultCC,
+ swift_dynamicCastObjCProtocolConditional, C_CC,
RETURNS(ObjCPtrTy),
ARGS(ObjCPtrTy, SizeTy, Int8PtrPtrTy),
ATTRS(NoUnwind))
// id swift_dynamicCastMetatypeToObjectUnconditional(type *type);
FUNCTION(DynamicCastMetatypeToObjectUnconditional,
- swift_dynamicCastMetatypeToObjectUnconditional, DefaultCC,
+ swift_dynamicCastMetatypeToObjectUnconditional, C_CC,
RETURNS(ObjCPtrTy),
ARGS(TypeMetadataPtrTy),
ATTRS(NoUnwind, ReadNone))
// id swift_dynamicCastMetatypeToObjectConditional(type *type);
FUNCTION(DynamicCastMetatypeToObjectConditional,
- swift_dynamicCastMetatypeToObjectConditional, DefaultCC,
+ swift_dynamicCastMetatypeToObjectConditional, C_CC,
RETURNS(ObjCPtrTy),
ARGS(TypeMetadataPtrTy),
ATTRS(NoUnwind, ReadNone))
// witness_table* swift_conformsToProtocol(type*, protocol*);
FUNCTION(ConformsToProtocol,
- swift_conformsToProtocol, DefaultCC,
+ swift_conformsToProtocol, C_CC,
RETURNS(WitnessTablePtrTy),
ARGS(TypeMetadataPtrTy, ProtocolDescriptorPtrTy),
ATTRS(NoUnwind, ReadNone))
// bool swift_isClassType(type*);
FUNCTION(IsClassType,
- swift_isClassType, DefaultCC,
+ swift_isClassType, C_CC,
RETURNS(Int1Ty),
ARGS(TypeMetadataPtrTy),
ATTRS(ZExt, NoUnwind, ReadNone))
// bool swift_isOptionalType(type*);
FUNCTION(IsOptionalType,
- swift_isOptionalType, DefaultCC,
+ swift_isOptionalType, C_CC,
RETURNS(Int1Ty),
ARGS(TypeMetadataPtrTy),
ATTRS(ZExt, NoUnwind, ReadNone))
@@ -1196,7 +1173,7 @@
// void swift_once(swift_once_t *predicate,
// void (*function_code)(RefCounted*),
// void *context);
-FUNCTION(Once, swift_once, DefaultCC,
+FUNCTION(Once, swift_once, C_CC,
RETURNS(VoidTy),
ARGS(OnceTy->getPointerTo(), Int8PtrTy, Int8PtrTy),
ATTRS())
@@ -1204,7 +1181,7 @@
// void swift_registerProtocols(const ProtocolRecord *begin,
// const ProtocolRecord *end)
FUNCTION(RegisterProtocols,
- swift_registerProtocols, DefaultCC,
+ swift_registerProtocols, C_CC,
RETURNS(VoidTy),
ARGS(ProtocolRecordPtrTy, ProtocolRecordPtrTy),
ATTRS(NoUnwind))
@@ -1212,29 +1189,29 @@
// void swift_registerProtocolConformances(const ProtocolConformanceRecord *begin,
// const ProtocolConformanceRecord *end)
FUNCTION(RegisterProtocolConformances,
- swift_registerProtocolConformances, DefaultCC,
+ swift_registerProtocolConformances, C_CC,
RETURNS(VoidTy),
ARGS(RelativeAddressPtrTy, RelativeAddressPtrTy),
ATTRS(NoUnwind))
FUNCTION(RegisterTypeMetadataRecords,
- swift_registerTypeMetadataRecords, DefaultCC,
+ swift_registerTypeMetadataRecords, C_CC,
RETURNS(VoidTy),
ARGS(TypeMetadataRecordPtrTy, TypeMetadataRecordPtrTy),
ATTRS(NoUnwind))
// void swift_beginAccess(void *pointer, ValueBuffer *scratch, size_t flags);
-FUNCTION(BeginAccess, swift_beginAccess, DefaultCC,
+FUNCTION(BeginAccess, swift_beginAccess, C_CC,
RETURNS(VoidTy),
ARGS(Int8PtrTy, getFixedBufferTy()->getPointerTo(), SizeTy, Int8PtrTy),
ATTRS(NoUnwind))
// void swift_endAccess(ValueBuffer *scratch);
-FUNCTION(EndAccess, swift_endAccess, DefaultCC,
+FUNCTION(EndAccess, swift_endAccess, C_CC,
RETURNS(VoidTy),
ARGS(getFixedBufferTy()->getPointerTo()),
ATTRS(NoUnwind))
-FUNCTION(InstantiateObjCClass, swift_instantiateObjCClass, DefaultCC,
+FUNCTION(InstantiateObjCClass, swift_instantiateObjCClass, C_CC,
RETURNS(VoidTy),
ARGS(TypeMetadataPtrTy),
ATTRS(NoUnwind))
@@ -1358,33 +1335,23 @@
RETURNS(RefCountedPtrTy),
ARGS(Int8PtrTy, Int8PtrTy),
ATTRS(NoUnwind))
-FUNCTION(CopyKeyPathTrivialIndices, swift_copyKeyPathTrivialIndices, DefaultCC,
+FUNCTION(CopyKeyPathTrivialIndices, swift_copyKeyPathTrivialIndices, C_CC,
RETURNS(VoidTy),
ARGS(Int8PtrTy, Int8PtrTy, SizeTy),
ATTRS(NoUnwind))
-#if SWIFT_OBJC_INTEROP || !defined(SWIFT_RUNTIME_GENERATE_GLOBAL_SYMBOLS)
-
-// Put here all definitions of runtime functions which are:
-// - only available when SWIFT_OBJC_INTEROP is enabled
-// - need a global function pointer referring to their implementation,
-// e.g. those defined FUNCTION_WITH_GLOBAL_SYMBOL_AND_IMPL or using
-// the RegisterPreservingCC calling convention.
-
-FUNCTION(GetInitializedObjCClass, swift_getInitializedObjCClass, RegisterPreservingCC,
+FUNCTION(GetInitializedObjCClass, swift_getInitializedObjCClass, C_CC,
RETURNS(ObjCClassPtrTy),
ARGS(ObjCClassPtrTy),
ATTRS(NoUnwind))
// void swift_objc_swift3ImplicitObjCEntrypoint(id self, SEL selector)
FUNCTION(Swift3ImplicitObjCEntrypoint, swift_objc_swift3ImplicitObjCEntrypoint,
- DefaultCC,
+ C_CC,
RETURNS(VoidTy),
ARGS(ObjCPtrTy, ObjCSELTy, Int8PtrTy, SizeTy, SizeTy, SizeTy, Int8PtrTy),
ATTRS(NoUnwind))
-#endif
-
FUNCTION(VerifyTypeLayoutAttribute, _swift_debug_verifyTypeLayoutAttribute,
C_CC,
RETURNS(VoidTy),
@@ -1396,6 +1363,5 @@
#undef ATTRS
#undef NO_ARGS
#undef NO_ATTRS
-#undef FUNCTION_WITH_GLOBAL_SYMBOL_AND_IMPL
#undef FUNCTION
#undef FUNCTION_NAME
diff --git a/include/swift/SIL/TypeLowering.h b/include/swift/SIL/TypeLowering.h
index d11a0a2..09fa63a 100644
--- a/include/swift/SIL/TypeLowering.h
+++ b/include/swift/SIL/TypeLowering.h
@@ -884,6 +884,9 @@
GenericEnvironment *env,
bool isMutable);
+ CanSILBoxType getBoxTypeForEnumElement(SILType enumType,
+ EnumElementDecl *elt);
+
private:
CanType getLoweredRValueType(AbstractionPattern origType, CanType substType);
diff --git a/lib/AST/ASTVerifier.cpp b/lib/AST/ASTVerifier.cpp
index 48563b9..133c867 100644
--- a/lib/AST/ASTVerifier.cpp
+++ b/lib/AST/ASTVerifier.cpp
@@ -1069,8 +1069,17 @@
Type srcObj = checkLValue(E->getSubExpr()->getType(),
"result of InOutExpr");
auto DestTy = E->getType()->castTo<InOutType>()->getObjectType();
-
- checkSameType(DestTy, srcObj, "object types for InOutExpr");
+
+ // HACK: Allow differences in optionality of the source and
+ // result types. When IUO is gone from the type system we'll no
+ // longer need this.
+ auto srcOptObjTy = srcObj->getAnyOptionalObjectType();
+ auto dstOptObjTy = DestTy->getAnyOptionalObjectType();
+ if (srcOptObjTy && dstOptObjTy) {
+ checkSameType(srcOptObjTy, dstOptObjTy, "object types for InOutExpr");
+ } else {
+ checkSameType(DestTy, srcObj, "object types for InOutExpr");
+ }
verifyCheckedBase(E);
}
diff --git a/lib/Demangling/Demangler.cpp b/lib/Demangling/Demangler.cpp
index a0c204f..f1ee4fd 100644
--- a/lib/Demangling/Demangler.cpp
+++ b/lib/Demangling/Demangler.cpp
@@ -120,16 +120,13 @@
int swift::Demangle::getManglingPrefixLength(llvm::StringRef mangledName) {
if (mangledName.empty()) return 0;
- // Check for the swift-4 prefix
- if (mangledName.size() >= 3 && mangledName[0] == '_' &&
- mangledName[1] == 'T' && mangledName[2] == '0')
- return 3;
+ llvm::StringRef prefixes[] = {/*Swift 4*/ "_T0", /*Swift > 4*/ "$S", "_$S"};
- // Check for the swift > 4 prefix
- unsigned Offset = (mangledName[0] == '_' ? 1 : 0);
- if (mangledName.size() >= Offset + 1 &&
- mangledName[Offset] == '$' && mangledName[Offset + 1] == 'S')
- return Offset + 2;
+ // Look for any of the known prefixes
+ for (auto prefix : prefixes) {
+ if (mangledName.startswith(prefix))
+ return prefix.size();
+ }
return 0;
}
@@ -142,13 +139,12 @@
}
bool swift::Demangle::isSwiftSymbol(const char *mangledName) {
- StringRef mangledNameRef(mangledName, 4);
+ StringRef mangledNameRef(mangledName);
return isSwiftSymbol(mangledNameRef);
}
bool swift::Demangle::isOldFunctionTypeMangling(llvm::StringRef mangledName) {
- return mangledName.size() >= 2 && mangledName[0] == '_' &&
- mangledName[1] == 'T';
+ return mangledName.startswith("_T");
}
llvm::StringRef swift::Demangle::dropSwiftManglingPrefix(StringRef mangledName){
diff --git a/lib/Demangling/OldRemangler.cpp b/lib/Demangling/OldRemangler.cpp
index f7deb90..f0e44a8 100644
--- a/lib/Demangling/OldRemangler.cpp
+++ b/lib/Demangling/OldRemangler.cpp
@@ -406,7 +406,9 @@
static bool isInSwiftModule(Node *node) {
Node *context = node->getFirstChild();
return (context->getKind() == Node::Kind::Module &&
- context->getText() == STDLIB_NAME);
+ context->getText() == STDLIB_NAME &&
+ // Check for private declarations in Swift
+ node->getChild(1)->getKind() == Node::Kind::Identifier);
};
bool Remangler::mangleStandardSubstitution(Node *node) {
diff --git a/lib/IRGen/IRGenModule.cpp b/lib/IRGen/IRGenModule.cpp
index f105199..d823999 100644
--- a/lib/IRGen/IRGenModule.cpp
+++ b/lib/IRGen/IRGenModule.cpp
@@ -404,25 +404,7 @@
C_CC = llvm::CallingConv::C;
// TODO: use "tinycc" on platforms that support it
- DefaultCC = SWIFT_LLVM_CC(DefaultCC);
- // If it is an interpreter, don't use try to use any
- // advanced calling conventions and use instead a
- // more conservative C calling convention. This
- // makes sure that none of the registers eventually
- // used by the dynamic linker are used by generated code.
- // TODO: Check that the deployment target supports the new
- // calling convention. Older versions of the runtime library
- // may not contain the entries using the new calling convention.
-
- // Only use the new calling conventions on platforms that support it.
- auto Arch = Triple.getArch();
- (void)Arch;
- if (SWIFT_RT_USE_RegisterPreservingCC &&
- Arch == llvm::Triple::ArchType::aarch64)
- RegisterPreservingCC = SWIFT_LLVM_CC(RegisterPreservingCC);
- else
- RegisterPreservingCC = DefaultCC;
-
+ DefaultCC = SWIFT_DEFAULT_LLVM_CC;
SwiftCC = llvm::CallingConv::Swift;
if (IRGen.Opts.DebugInfoKind > IRGenDebugInfoKind::None)
@@ -530,123 +512,13 @@
return cache;
}
-llvm::Constant *swift::getWrapperFn(llvm::Module &Module,
- llvm::Constant *&cache,
- char const *name,
- char const *symbol,
- llvm::CallingConv::ID cc,
- llvm::ArrayRef<llvm::Type *> retTypes,
- llvm::ArrayRef<llvm::Type *> argTypes,
- ArrayRef<Attribute::AttrKind> attrs) {
- assert(symbol && "Symbol name should be defined for a wrapper function");
- // Wrapper names should have a prefix to distinguish them from the
- // actual runtime functions.
- llvm::SmallString<128> wrapperNameStr;
- llvm::raw_svector_ostream buffer(wrapperNameStr);
- buffer << SWIFT_WRAPPER_PREFIX;
- buffer << name;
- const char *wrapperName = wrapperNameStr.c_str();
- auto fn = getRuntimeFn(Module, cache, wrapperName, cc,
- retTypes, argTypes, attrs);
- auto *fun = dyn_cast<llvm::Function>(fn);
- assert(fun && "Wrapper should be an llvm::Function");
- // Do not inline wrappers, because this would result in a code size increase.
- fun->addAttribute(llvm::AttributeList::FunctionIndex,
- llvm::Attribute::NoInline);
- assert(fun->hasFnAttribute(llvm::Attribute::NoInline) &&
- "Wrappers should not be inlined");
- if (fun->empty()) {
- // All wrappers should have ODR linkage so that a linker can detect them
- // and leave only one copy.
- fun->setLinkage(llvm::Function::LinkOnceODRLinkage);
- fun->setVisibility(llvm::Function::HiddenVisibility);
- fun->setDLLStorageClass(llvm::Function::DefaultStorageClass);
- fun->setDoesNotThrow();
-
- // Add the body of a wrapper.
- // It simply invokes the actual implementation of the runtime entry
- // by means of indirect call through a pointer stored in the
- // global variable.
- llvm::IRBuilder<> Builder(Module.getContext());
- llvm::BasicBlock *bb =
- llvm::BasicBlock::Create(Module.getContext(), "entry", fun);
- Builder.SetInsertPoint(bb);
- auto fnTy = fun->getFunctionType();
- auto fnPtrTy = llvm::PointerType::getUnqual(fnTy);
-
- auto *globalFnPtr = new llvm::GlobalVariable(
- Module, fnPtrTy, false, llvm::GlobalValue::ExternalLinkage, nullptr,
- symbol);
- if (::useDllStorage(llvm::Triple(Module.getTargetTriple())))
- globalFnPtr->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
-
- // Forward all arguments.
- llvm::SmallVector<llvm::Value *, 4> args;
- for (auto &arg: fun->args()) {
- args.push_back(&arg);
- }
-
-
- auto fnPtr = Builder.CreateLoad(globalFnPtr, "load");
-
- auto call = Builder.CreateCall(fnPtr, args);
- call->setCallingConv(cc);
- call->setTailCall(true);
- for (auto Attr : attrs)
- if (isReturnedAttribute(Attr)) {
- call->addParamAttr(0, llvm::Attribute::Returned);
- }
- auto VoidTy = llvm::Type::getVoidTy(Module.getContext());
- if (retTypes.size() == 1 && *retTypes.begin() == VoidTy)
- Builder.CreateRetVoid();
- else
- Builder.CreateRet(call);
- }
-
- return fn;
-}
-
#define QUOTE(...) __VA_ARGS__
#define STR(X) #X
-#define FUNCTION_FOR_CONV_DefaultCC(ID, NAME, CC, RETURNS, ARGS, ATTRS) \
- FUNCTION_IMPL(ID, NAME, CC, QUOTE(RETURNS), QUOTE(ARGS), QUOTE(ATTRS))
-
-#define FUNCTION_FOR_CONV_C_CC(ID, NAME, CC, RETURNS, ARGS, ATTRS) \
- FUNCTION_IMPL(ID, NAME, CC, QUOTE(RETURNS), QUOTE(ARGS), QUOTE(ATTRS))
-
-#define FUNCTION_FOR_CONV_SwiftCC(ID, NAME, CC, RETURNS, ARGS, ATTRS) \
- FUNCTION_IMPL(ID, NAME, CC, QUOTE(RETURNS), QUOTE(ARGS), QUOTE(ATTRS))
-
-#define FUNCTION_FOR_CONV_RegisterPreservingCC(ID, NAME, CC, RETURNS, ARGS, \
- ATTRS) \
- FUNCTION_WITH_GLOBAL_SYMBOL_IMPL(ID, NAME, SWIFT_RT_ENTRY_REF(NAME), CC, \
- QUOTE(RETURNS), QUOTE(ARGS), QUOTE(ATTRS))
-
#define FUNCTION(ID, NAME, CC, RETURNS, ARGS, ATTRS) \
- FUNCTION_FOR_CONV_##CC(ID, NAME, CC, QUOTE(RETURNS), QUOTE(ARGS), \
- QUOTE(ATTRS))
-
-#define FUNCTION_WITH_GLOBAL_SYMBOL_FOR_CONV_DefaultCC(ID, NAME, SYMBOL, CC, \
- RETURNS, ARGS, ATTRS) \
FUNCTION_IMPL(ID, NAME, CC, QUOTE(RETURNS), QUOTE(ARGS), QUOTE(ATTRS))
-#define FUNCTION_WITH_GLOBAL_SYMBOL_FOR_CONV_C_CC(ID, NAME, SYMBOL, CC, \
- RETURNS, ARGS, ATTRS) \
- FUNCTION_IMPL(ID, NAME, CC, QUOTE(RETURNS), QUOTE(ARGS), QUOTE(ATTRS))
-
-#define FUNCTION_WITH_GLOBAL_SYMBOL_FOR_CONV_RegisterPreservingCC( \
- ID, NAME, SYMBOL, CC, RETURNS, ARGS, ATTRS) \
- FUNCTION_WITH_GLOBAL_SYMBOL_IMPL(ID, NAME, SYMBOL, CC, QUOTE(RETURNS), \
- QUOTE(ARGS), QUOTE(ATTRS))
-
-#define FUNCTION_WITH_GLOBAL_SYMBOL_AND_IMPL(ID, NAME, SYMBOL, IMPL, CC, \
- RETURNS, ARGS, ATTRS) \
- FUNCTION_WITH_GLOBAL_SYMBOL_FOR_CONV_##CC( \
- ID, NAME, SYMBOL, CC, QUOTE(RETURNS), QUOTE(ARGS), QUOTE(ATTRS))
-
-#define RETURNS(...) \
- { __VA_ARGS__ }
+#define RETURNS(...) { __VA_ARGS__ }
#define ARGS(...) { __VA_ARGS__ }
#define NO_ARGS {}
#define ATTRS(...) { __VA_ARGS__ }
@@ -658,14 +530,6 @@
return getRuntimeFn(Module, ID##Fn, #NAME, CC, RETURNS, ARGS, ATTRS); \
}
-#define FUNCTION_WITH_GLOBAL_SYMBOL_IMPL(ID, NAME, SYMBOL_NAME, CC, RETURNS, \
- ARGS, ATTRS) \
- llvm::Constant *IRGenModule::get##ID##Fn() { \
- using namespace RuntimeConstants; \
- return getWrapperFn(Module, ID##Fn, #NAME, STR(SYMBOL_NAME), CC, RETURNS, \
- ARGS, ATTRS); \
- }
-
#include "swift/Runtime/RuntimeFunctions.def"
std::pair<llvm::GlobalVariable *, llvm::Constant *>
diff --git a/lib/IRGen/IRGenModule.h b/lib/IRGen/IRGenModule.h
index 189f223..cf7033f 100644
--- a/lib/IRGen/IRGenModule.h
+++ b/lib/IRGen/IRGenModule.h
@@ -522,8 +522,7 @@
llvm::CallingConv::ID C_CC; /// standard C calling convention
llvm::CallingConv::ID DefaultCC; /// default calling convention
- llvm::CallingConv::ID RegisterPreservingCC; /// lightweight calling convention
- llvm::CallingConv::ID SwiftCC; /// swift calling convention
+ llvm::CallingConv::ID SwiftCC; /// swift calling convention
Signature getAssociatedTypeMetadataAccessFunctionSignature();
Signature getAssociatedTypeWitnessTableAccessFunctionSignature();
diff --git a/lib/IRGen/StructMetadataVisitor.h b/lib/IRGen/StructMetadataVisitor.h
index 17dc558..15e29fc 100644
--- a/lib/IRGen/StructMetadataVisitor.h
+++ b/lib/IRGen/StructMetadataVisitor.h
@@ -50,14 +50,14 @@
// If changing this layout, you must update the magic number in
// emitParentMetadataRef.
-
+
+ // Instantiation-specific.
+ asImpl().addGenericFields(Target, Target->getDeclaredTypeInContext());
+
// Struct field offsets.
asImpl().noteStartOfFieldOffsets();
for (VarDecl *prop : Target->getStoredProperties())
asImpl().addFieldOffset(prop);
-
- // Instantiation-specific.
- asImpl().addGenericFields(Target, Target->getDeclaredTypeInContext());
}
// Note the start of the field offset vector.
diff --git a/lib/LLVMPasses/ARCEntryPointBuilder.h b/lib/LLVMPasses/ARCEntryPointBuilder.h
index 195f130..a234ea0 100644
--- a/lib/LLVMPasses/ARCEntryPointBuilder.h
+++ b/lib/LLVMPasses/ARCEntryPointBuilder.h
@@ -69,7 +69,6 @@
NullablePtr<Type> BridgeObjectPtrTy;
llvm::CallingConv::ID DefaultCC;
- llvm::CallingConv::ID RegisterPreservingCC;
llvm::CallInst *CreateCall(Constant *Fn, Value *V) {
CallInst *CI = B.CreateCall(Fn, V);
@@ -88,27 +87,7 @@
public:
ARCEntryPointBuilder(Function &F)
: B(&*F.begin()), Retain(), ObjectPtrTy(),
- DefaultCC(SWIFT_LLVM_CC(DefaultCC)) {
- //If the target does not support the new calling convention,
- //set RegisterPreservingCC to use a default calling convention.
- RegisterPreservingCC = DefaultCC;
-
- // Check if the register preserving calling convention
- // is supported by the backend and should be used
- // for the deployment target provided for this compilation.
- if (SWIFT_RT_USE_RegisterPreservingCC) {
- bool ShouldUseRegisterPreservingCC = false;
- auto &TargetTriple = F.getParent()->getTargetTriple();
- llvm::Triple Triple(TargetTriple);
- auto Arch = Triple.getArch();
- if (Arch == llvm::Triple::ArchType::aarch64) {
- ShouldUseRegisterPreservingCC = true;
- }
-
- if (ShouldUseRegisterPreservingCC)
- RegisterPreservingCC = SWIFT_LLVM_CC(RegisterPreservingCC);
- }
- }
+ DefaultCC(SWIFT_DEFAULT_LLVM_CC) { }
~ARCEntryPointBuilder() = default;
ARCEntryPointBuilder(ARCEntryPointBuilder &&) = delete;
@@ -232,12 +211,10 @@
auto *ObjectPtrTy = getObjectPtrTy();
llvm::Constant *cache = nullptr;
- Retain = getWrapperFn(
+ Retain = getRuntimeFn(
getModule(), cache,
isNonAtomic(OrigI) ? "swift_nonatomic_retain" : "swift_retain",
- isNonAtomic(OrigI) ? SWIFT_RT_ENTRY_REF_AS_STR(swift_nonatomic_retain)
- : SWIFT_RT_ENTRY_REF_AS_STR(swift_retain),
- RegisterPreservingCC, {ObjectPtrTy}, {ObjectPtrTy},
+ DefaultCC, {ObjectPtrTy}, {ObjectPtrTy},
{NoUnwind, FirstParamReturned});
return Retain.get();
@@ -251,12 +228,10 @@
auto *VoidTy = Type::getVoidTy(getModule().getContext());
llvm::Constant *cache = nullptr;
- Release = getWrapperFn(
+ Release = getRuntimeFn(
getModule(), cache,
isNonAtomic(OrigI) ? "swift_nonatomic_release" : "swift_release",
- isNonAtomic(OrigI) ? SWIFT_RT_ENTRY_REF_AS_STR(swift_nonatomic_release)
- : SWIFT_RT_ENTRY_REF_AS_STR(swift_release),
- RegisterPreservingCC, {VoidTy}, {ObjectPtrTy}, {NoUnwind});
+ DefaultCC, {VoidTy}, {ObjectPtrTy}, {NoUnwind});
return Release.get();
}
@@ -288,12 +263,10 @@
auto *Int32Ty = Type::getInt32Ty(getModule().getContext());
llvm::Constant *cache = nullptr;
- RetainN = getWrapperFn(
+ RetainN = getRuntimeFn(
getModule(), cache,
isNonAtomic(OrigI) ? "swift_nonatomic_retain_n" : "swift_retain_n",
- isNonAtomic(OrigI) ? SWIFT_RT_ENTRY_REF_AS_STR(swift_nonatomic_retain_n)
- : SWIFT_RT_ENTRY_REF_AS_STR(swift_retain_n),
- RegisterPreservingCC, {ObjectPtrTy}, {ObjectPtrTy, Int32Ty},
+ DefaultCC, {ObjectPtrTy}, {ObjectPtrTy, Int32Ty},
{NoUnwind, FirstParamReturned});
return RetainN.get();
@@ -308,13 +281,10 @@
auto *VoidTy = Type::getVoidTy(getModule().getContext());
llvm::Constant *cache = nullptr;
- ReleaseN = getWrapperFn(
+ ReleaseN = getRuntimeFn(
getModule(), cache,
isNonAtomic(OrigI) ? "swift_nonatomic_release_n" : "swift_release_n",
- isNonAtomic(OrigI)
- ? SWIFT_RT_ENTRY_REF_AS_STR(swift_nonatomic_release_n)
- : SWIFT_RT_ENTRY_REF_AS_STR(swift_release_n),
- RegisterPreservingCC, {VoidTy}, {ObjectPtrTy, Int32Ty}, {NoUnwind});
+ DefaultCC, {VoidTy}, {ObjectPtrTy, Int32Ty}, {NoUnwind});
return ReleaseN.get();
}
diff --git a/lib/LLVMPasses/LLVMARCOpts.h b/lib/LLVMPasses/LLVMARCOpts.h
index 93a82dd..6edec7f 100644
--- a/lib/LLVMPasses/LLVMARCOpts.h
+++ b/lib/LLVMPasses/LLVMARCOpts.h
@@ -18,10 +18,6 @@
#include "llvm/IR/Function.h"
#include "llvm/ADT/StringSwitch.h"
-#if defined(SWIFT_WRAPPER_PREFIX)
-#define SWIFT_WRAPPER_NAME(Name) SWIFT_WRAPPER_PREFIX Name
-#endif
-
namespace swift {
enum RT_Kind {
@@ -50,15 +46,6 @@
.Case("__swift_" #TextualName, RT_ ## Name)
#include "LLVMSwift.def"
-#if defined(SWIFT_WRAPPER_PREFIX)
-#define SWIFT_FUNC(Name, MemBehavior, TextualName) \
- .Case(SWIFT_WRAPPER_NAME("swift_" #TextualName), RT_ ## Name)
-#define OBJC_FUNC(Name, MemBehavior, TextualName) \
- .Case(SWIFT_WRAPPER_NAME("objc_" #TextualName), RT_ ## Name)
-#define SWIFT_INTERNAL_FUNC_NEVER_NONATOMIC(Name, MemBehavior, TextualName)
-#include "LLVMSwift.def"
-#endif
-
// Support non-atomic versions of reference counting entry points.
#define SWIFT_FUNC(Name, MemBehavior, TextualName) \
.Case("swift_nonatomic_" #TextualName, RT_ ## Name)
@@ -67,14 +54,6 @@
#define SWIFT_INTERNAL_FUNC_NEVER_NONATOMIC(Name, MemBehavior, TextualName)
#include "LLVMSwift.def"
-#if defined(SWIFT_WRAPPER_PREFIX)
-#define SWIFT_FUNC(Name, MemBehavior, TextualName) \
- .Case(SWIFT_WRAPPER_NAME("swift_nonatomic_" #TextualName), RT_ ## Name)
-#define OBJC_FUNC(Name, MemBehavior, TextualName) \
- .Case(SWIFT_WRAPPER_NAME("objc_nonatomic_" #TextualName), RT_ ## Name)
-#define SWIFT_INTERNAL_FUNC_NEVER_NONATOMIC(Name, MemBehavior, TextualName)
-#include "LLVMSwift.def"
-#endif
.Default(RT_Unknown);
}
diff --git a/lib/SIL/SILType.cpp b/lib/SIL/SILType.cpp
index ef76be1..a250b89 100644
--- a/lib/SIL/SILType.cpp
+++ b/lib/SIL/SILType.cpp
@@ -336,17 +336,19 @@
return SILType(objectType, getCategory());
}
+ // If the case is indirect, then the payload is boxed.
+ if (elt->isIndirect() || elt->getParentEnum()->isIndirect()) {
+ auto box = M.Types.getBoxTypeForEnumElement(*this, elt);
+ return SILType(SILType::getPrimitiveObjectType(box).getSwiftRValueType(),
+ getCategory());
+ }
+
auto substEltTy =
getSwiftRValueType()->getTypeOfMember(M.getSwiftModule(), elt,
elt->getArgumentInterfaceType());
auto loweredTy =
M.Types.getLoweredType(M.Types.getAbstractionPattern(elt), substEltTy);
- // If the case is indirect, then the payload is boxed.
- if (elt->isIndirect() || elt->getParentEnum()->isIndirect())
- loweredTy = SILType::getPrimitiveObjectType(
- SILBoxType::get(loweredTy.getSwiftRValueType()));
-
return SILType(loweredTy.getSwiftRValueType(), getCategory());
}
diff --git a/lib/SIL/TypeLowering.cpp b/lib/SIL/TypeLowering.cpp
index 839b958..1a254f1 100644
--- a/lib/SIL/TypeLowering.cpp
+++ b/lib/SIL/TypeLowering.cpp
@@ -2516,6 +2516,45 @@
return boxType;
}
+CanSILBoxType TypeConverter::getBoxTypeForEnumElement(SILType enumType,
+ EnumElementDecl *elt) {
+
+ auto *enumDecl = enumType.getEnumOrBoundGenericEnum();
+
+ assert(elt->getDeclContext() == enumDecl);
+ assert(elt->isIndirect() || elt->getParentEnum()->isIndirect());
+
+ auto &C = M.getASTContext();
+
+ auto boxSignature = getEffectiveGenericSignature(enumDecl);
+
+ if (boxSignature == CanGenericSignature()) {
+ auto eltIntfTy = elt->getArgumentInterfaceType();
+ auto boxVarTy = getLoweredType(eltIntfTy).getSwiftRValueType();
+ auto layout = SILLayout::get(C, nullptr, SILField(boxVarTy, true));
+ return SILBoxType::get(C, layout, {});
+ }
+
+ // Use the enum's signature for the box type.
+ auto boundEnum = enumType.getSwiftRValueType();
+
+ // Lower the enum element's argument in the box's context.
+ auto eltIntfTy = elt->getArgumentInterfaceType();
+ GenericContextScope scope(*this, boxSignature);
+ auto boxVarTy = getLoweredType(getAbstractionPattern(elt), eltIntfTy)
+ .getSwiftRValueType();
+ auto layout = SILLayout::get(C, boxSignature, SILField(boxVarTy, true));
+
+ // Instantiate the layout with enum's substitution list.
+ auto subMap = boundEnum->getContextSubstitutionMap(
+ M.getSwiftModule(), enumDecl, enumDecl->getGenericEnvironment());
+ SmallVector<Substitution, 4> genericArgs;
+ boxSignature->getSubstitutions(subMap, genericArgs);
+
+ auto boxTy = SILBoxType::get(C, layout, genericArgs);
+ return boxTy;
+}
+
static void countNumberOfInnerFields(unsigned &fieldsCount, SILModule &Module,
SILType Ty) {
if (auto *structDecl = Ty.getStructOrBoundGenericStruct()) {
diff --git a/lib/SILGen/SILGenApply.cpp b/lib/SILGen/SILGenApply.cpp
index 3b49538..2dfaf13 100644
--- a/lib/SILGen/SILGenApply.cpp
+++ b/lib/SILGen/SILGenApply.cpp
@@ -3541,7 +3541,7 @@
// throws, we know to deallocate the uninitialized box.
if (element->isIndirect() ||
element->getParentEnum()->isIndirect()) {
- auto boxTy = SILBoxType::get(payloadTL.getLoweredType().getSwiftRValueType());
+ auto boxTy = SGM.M.Types.getBoxTypeForEnumElement(enumTy, element);
auto *box = B.createAllocBox(loc, boxTy);
auto *addr = B.createProjectBox(loc, box, 0);
diff --git a/lib/Sema/CSApply.cpp b/lib/Sema/CSApply.cpp
index 0a040e7..a0576f0 100644
--- a/lib/Sema/CSApply.cpp
+++ b/lib/Sema/CSApply.cpp
@@ -5518,6 +5518,38 @@
return 0;
}
+// HACK: Support calling functions with inouts of differing kinds of
+// optionality so that we can warn about overloading by IUO vs. plain
+// Optional and allow users to correct the issue by removing an
+// overload and passing the differently-optional value to the
+// remaining overload.
+bool inOutOptionalityDifferenceHack(Expr *arg, Type paramType,
+ ConstraintSystem &cs) {
+ auto *inOutArgTy = cs.getType(arg)->getAs<InOutType>();
+ if (!inOutArgTy)
+ return false;
+
+ auto *inOutParamTy = paramType->getAs<InOutType>();
+ if (!inOutParamTy)
+ return false;
+
+ OptionalTypeKind argOTK;
+ OptionalTypeKind paramOTK;
+ auto argObjTy = inOutArgTy->getObjectType()->getAnyOptionalObjectType(argOTK);
+ auto paramObjTy =
+ inOutParamTy->getObjectType()->getAnyOptionalObjectType(paramOTK);
+
+ if (argOTK == paramOTK || argOTK == OTK_None || paramOTK == OTK_None)
+ return false;
+
+ if (!argObjTy->isEqual(paramObjTy))
+ return false;
+
+ // Hammer over the argument type with the expected parameter type.
+ cs.setType(arg, paramType);
+ return true;
+}
+
Expr *ExprRewriter::coerceCallArguments(
Expr *arg, AnyFunctionType *funcType,
ApplyExpr *apply,
@@ -5748,11 +5780,16 @@
continue;
}
- // Convert the argument.
- auto convertedArg = coerceToType(arg, paramType,
- getArgLocator(argIdx, paramIdx));
- if (!convertedArg)
- return nullptr;
+ Expr *convertedArg;
+ if (inOutOptionalityDifferenceHack(arg, paramType, cs)) {
+ convertedArg = arg;
+ } else {
+ // Convert the argument.
+ convertedArg =
+ coerceToType(arg, paramType, getArgLocator(argIdx, paramIdx));
+ if (!convertedArg)
+ return nullptr;
+ }
// Add the converted argument.
fromTupleExpr[argIdx] = convertedArg;
diff --git a/lib/Sema/CSRanking.cpp b/lib/Sema/CSRanking.cpp
index 4f38811..1da00ae 100644
--- a/lib/Sema/CSRanking.cpp
+++ b/lib/Sema/CSRanking.cpp
@@ -80,6 +80,8 @@
case SK_ValueToPointerConversion:
log << "value-to-pointer conversion";
break;
+ case SK_InOutOptionalityConversion:
+ log << "inout optionality conversion";
}
log << ")\n";
}
diff --git a/lib/Sema/CSSimplify.cpp b/lib/Sema/CSSimplify.cpp
index d8d6345..b616aba 100644
--- a/lib/Sema/CSSimplify.cpp
+++ b/lib/Sema/CSSimplify.cpp
@@ -1863,16 +1863,32 @@
locator.withPathElement(
ConstraintLocator::ArrayElementType));
- case TypeKind::InOut:
+ case TypeKind::InOut: {
// If the RHS is an inout type, the LHS must be an @lvalue type.
if (kind == ConstraintKind::BindParam ||
kind >= ConstraintKind::OperatorArgumentConversion)
return getTypeMatchFailure(locator);
-
- return matchTypes(cast<InOutType>(desugar1)->getObjectType(),
- cast<InOutType>(desugar2)->getObjectType(),
- ConstraintKind::Equal, subflags,
- locator.withPathElement(ConstraintLocator::ArrayElementType));
+
+ auto inoutObjTy1 = cast<InOutType>(desugar1)->getObjectType();
+ auto inoutObjTy2 = cast<InOutType>(desugar2)->getObjectType();
+
+ OptionalTypeKind OTK1;
+ OptionalTypeKind OTK2;
+ auto optionalObjTy1 = inoutObjTy1->getAnyOptionalObjectType(OTK1);
+ auto optionalObjTy2 = inoutObjTy2->getAnyOptionalObjectType(OTK2);
+ if (OTK1 != OTK2 && optionalObjTy1 && optionalObjTy2) {
+ increaseScore(ScoreKind::SK_InOutOptionalityConversion);
+ return matchTypes(inoutObjTy1,
+ inoutObjTy2,
+ ConstraintKind::ArgumentConversion, subflags,
+ locator.withPathElement(ConstraintLocator::ArrayElementType));
+ } else {
+ return matchTypes(inoutObjTy1,
+ inoutObjTy2,
+ ConstraintKind::Equal, subflags,
+ locator.withPathElement(ConstraintLocator::ArrayElementType));
+ }
+ }
case TypeKind::UnboundGeneric:
llvm_unreachable("Unbound generic type should have been opened");
diff --git a/lib/Sema/ConstraintSystem.h b/lib/Sema/ConstraintSystem.h
index f5af01b..11adc65 100644
--- a/lib/Sema/ConstraintSystem.h
+++ b/lib/Sema/ConstraintSystem.h
@@ -462,8 +462,12 @@
SK_KeyPathSubscript,
/// A conversion from a string, array, or inout to a pointer.
SK_ValueToPointerConversion,
+ /// A conversion from 'inout Optional<T>' to 'inout
+ /// ImplicitlyUnwrappedOptional<T>' or vice-versa.
+ /// FIXME: This goes away when IUO-as-a-type goes away.
+ SK_InOutOptionalityConversion,
- SK_LastScoreKind = SK_ValueToPointerConversion,
+ SK_LastScoreKind = SK_InOutOptionalityConversion,
};
/// The number of score kinds.
diff --git a/lib/Sema/TypeChecker.cpp b/lib/Sema/TypeChecker.cpp
index e9118d0..b2bbe27 100644
--- a/lib/Sema/TypeChecker.cpp
+++ b/lib/Sema/TypeChecker.cpp
@@ -675,8 +675,18 @@
verify(SF);
// Verify imported modules.
+ //
+ // Skip per-file verification in whole-module mode. Verifying imports
+ // between files could cause the importer to cache declarations without
+ // adding them to the ASTContext. This happens when the importer registers a
+ // declaration without a valid TypeChecker instance, as is the case during
+ // verification. A subsequent file may require that declaration to be fully
+ // imported (e.g. to synthesized a function body), but since it has already
+ // been cached, it will never be added to the ASTContext. The solution is to
+ // skip verification and avoid caching it.
#ifndef NDEBUG
- if (SF.Kind != SourceFileKind::REPL &&
+ if (!(Options & TypeCheckingFlags::DelayWholeModuleChecking) &&
+ SF.Kind != SourceFileKind::REPL &&
SF.Kind != SourceFileKind::SIL &&
!Ctx.LangOpts.DebuggerSupport) {
Ctx.verifyAllLoadedModules();
@@ -692,6 +702,21 @@
Ctx.diagnoseObjCMethodConflicts(SF);
Ctx.diagnoseObjCUnsatisfiedOptReqConflicts(SF);
Ctx.diagnoseUnintendedObjCMethodOverrides(SF);
+
+ // In whole-module mode, import verification is deferred until all files have
+ // been type checked. This avoids caching imported declarations when a valid
+ // type checker is not present. The same declaration may need to be fully
+ // imported by subsequent files.
+ //
+ // FIXME: some playgrounds tests (playground_lvalues.swift) fail with
+ // verification enabled.
+#if 0
+ if (SF.Kind != SourceFileKind::REPL &&
+ SF.Kind != SourceFileKind::SIL &&
+ !Ctx.LangOpts.DebuggerSupport) {
+ Ctx.verifyAllLoadedModules();
+ }
+#endif
}
bool swift::performTypeLocChecking(ASTContext &Ctx, TypeLoc &T,
diff --git a/stdlib/private/StdlibUnittestFoundationExtras/UnavailableFoundationMethodThunks.mm b/stdlib/private/StdlibUnittestFoundationExtras/UnavailableFoundationMethodThunks.mm
index ccb5ac0..3426c62 100644
--- a/stdlib/private/StdlibUnittestFoundationExtras/UnavailableFoundationMethodThunks.mm
+++ b/stdlib/private/StdlibUnittestFoundationExtras/UnavailableFoundationMethodThunks.mm
@@ -19,7 +19,7 @@
id *objects, NSUInteger rangeLocation,
NSUInteger rangeLength) {
[nsArray getObjects:objects range:NSMakeRange(rangeLocation, rangeLength)];
- [nsArray release];
+ SWIFT_CC_PLUSONE_GUARD([nsArray release]);
}
SWIFT_CC(swift) LLVM_LIBRARY_VISIBILITY
@@ -27,6 +27,6 @@
NSDictionary_getObjects(NSDictionary *_Nonnull nsDictionary,
id *objects, id *keys) {
[nsDictionary getObjects:objects andKeys:keys];
- [nsDictionary release];
+ SWIFT_CC_PLUSONE_GUARD([nsDictionary release]);
}
diff --git a/stdlib/public/SDK/Foundation/DataThunks.m b/stdlib/public/SDK/Foundation/DataThunks.m
index 90975bd..c014651 100644
--- a/stdlib/public/SDK/Foundation/DataThunks.m
+++ b/stdlib/public/SDK/Foundation/DataThunks.m
@@ -120,8 +120,8 @@
if (![path getFileSystemRepresentation:cpath maxLength:1024]) {
if (errorPtr) *errorPtr = _NSErrorWithFilePath(NSFileWriteInvalidFileNameError, path);
- [data release];
- [url release];
+ SWIFT_CC_PLUSONE_GUARD([data release]);
+ SWIFT_CC_PLUSONE_GUARD([url release]);
return NO;
}
@@ -137,8 +137,8 @@
int32_t fd = _NSOpenFileDescriptor(cpath, flags, protectionClass, 0666);
if (fd < 0) {
if (errorPtr) *errorPtr = _NSErrorWithFilePathAndErrno(errno, path, NO);
- [url release];
- [data release];
+ SWIFT_CC_PLUSONE_GUARD([url release]);
+ SWIFT_CC_PLUSONE_GUARD([data release]);
return NO;
}
@@ -172,12 +172,12 @@
if (errorPtr) {
*errorPtr = _NSErrorWithFilePathAndErrno(errno, path, NO);
}
- [url release];
- [data release];
+ SWIFT_CC_PLUSONE_GUARD([url release]);
+ SWIFT_CC_PLUSONE_GUARD([data release]);
return NO;
}
close(fd);
- [url release];
- [data release];
+ SWIFT_CC_PLUSONE_GUARD([url release]);
+ SWIFT_CC_PLUSONE_GUARD([data release]);
return YES;
}
diff --git a/stdlib/public/SDK/Foundation/TypePreservingNSNumber.mm b/stdlib/public/SDK/Foundation/TypePreservingNSNumber.mm
index 69f2b66..21b7672 100644
--- a/stdlib/public/SDK/Foundation/TypePreservingNSNumber.mm
+++ b/stdlib/public/SDK/Foundation/TypePreservingNSNumber.mm
@@ -325,7 +325,7 @@
} else if (CFGetTypeID(self_) == CFBooleanGetTypeID()) {
result = SwiftBool;
}
- [self_ release];
+ SWIFT_CC_PLUSONE_GUARD([self_ release]);
return result;
}
@@ -339,7 +339,7 @@
} \
C_TYPE result; \
memcpy(&result, self_->storage, sizeof(result)); \
- [self_ release]; \
+ SWIFT_CC_PLUSONE_GUARD([self_ release]); \
return result; \
}
diff --git a/stdlib/public/SwiftShims/RefCount.h b/stdlib/public/SwiftShims/RefCount.h
index 2bbefe9..13430e3 100644
--- a/stdlib/public/SwiftShims/RefCount.h
+++ b/stdlib/public/SwiftShims/RefCount.h
@@ -192,8 +192,7 @@
// FIXME: HACK: copied from HeapObject.cpp
extern "C" LLVM_LIBRARY_VISIBILITY LLVM_ATTRIBUTE_NOINLINE LLVM_ATTRIBUTE_USED
-void _swift_release_dealloc(swift::HeapObject *object)
-SWIFT_CC(RegisterPreservingCC_IMPL);
+void _swift_release_dealloc(swift::HeapObject *object);
namespace swift {
diff --git a/stdlib/public/core/DebuggerSupport.swift b/stdlib/public/core/DebuggerSupport.swift
index ab671fb..af7fbca 100644
--- a/stdlib/public/core/DebuggerSupport.swift
+++ b/stdlib/public/core/DebuggerSupport.swift
@@ -170,6 +170,11 @@
if isRoot || collectionStatus.isCollection { return true }
let count = Int(mirror.children.count)
if count > 0 { return true }
+ if let ds = mirror.displayStyle {
+ if ds == .`class` {
+ return true
+ }
+ }
if let sc = mirror.superclassMirror {
return ivarCount(mirror: sc) > 0
} else {
diff --git a/stdlib/public/core/RuntimeFunctionCounters.swift b/stdlib/public/core/RuntimeFunctionCounters.swift
index 5587ad2..3b3274f 100644
--- a/stdlib/public/core/RuntimeFunctionCounters.swift
+++ b/stdlib/public/core/RuntimeFunctionCounters.swift
@@ -18,6 +18,12 @@
// number of invocations, or per-object counters, which represent the
// number of runtime functions calls for a specific object.
+// By default, this feature is enabled only when assertions are enabled. To control it
+// separately, set the SWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS environment variable when
+// invoking build-script:
+// SWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS=TRUE ./utils/build-script ...
+#if SWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS
+
/// Collect all references inside the object using Mirrors.
/// - Parameter value: the value to be inspected
/// - Parameter references: the array which should contain the collected
@@ -541,3 +547,5 @@
mode: savedMode)
return (globalCountersBefore.diff(globalCountersAfter), objectsCountersDiff)
}
+
+#endif
diff --git a/stdlib/public/runtime/AnyHashableSupport.cpp b/stdlib/public/runtime/AnyHashableSupport.cpp
index 8a1b904..4861fbc 100644
--- a/stdlib/public/runtime/AnyHashableSupport.cpp
+++ b/stdlib/public/runtime/AnyHashableSupport.cpp
@@ -161,6 +161,7 @@
if (auto unboxedHashableWT =
swift_conformsToProtocol(type, &HashableProtocolDescriptor)) {
+#ifndef SWIFT_RUNTIME_ENABLE_GUARANTEED_NORMAL_ARGUMENTS
ValueBuffer unboxedCopyBuf;
// Allocate buffer.
OpaqueValue *unboxedValueCopy =
@@ -172,9 +173,15 @@
_swift_makeAnyHashableUpcastingToHashableBaseType(
unboxedValueCopy, anyHashableResultPointer, unboxedType,
unboxedHashableWT);
+
// Deallocate buffer.
unboxedType->deallocateBufferIn(&unboxedCopyBuf);
type->vw_destroy(value);
+#else
+ _swift_makeAnyHashableUpcastingToHashableBaseType(
+ unboxedValue, anyHashableResultPointer, unboxedType,
+ unboxedHashableWT);
+#endif
return;
}
}
diff --git a/stdlib/public/runtime/Array.cpp b/stdlib/public/runtime/Array.cpp
index 24f9faf..ec9b5de 100644
--- a/stdlib/public/runtime/Array.cpp
+++ b/stdlib/public/runtime/Array.cpp
@@ -134,7 +134,6 @@
} while (i != 0);
}
-SWIFT_CC(c)
SWIFT_RUNTIME_EXPORT
void swift_arrayInitWithCopy(OpaqueValue *dest, OpaqueValue *src, size_t count,
const Metadata *self) {
@@ -142,7 +141,6 @@
dest, src, count, self);
}
-SWIFT_CC(c)
SWIFT_RUNTIME_EXPORT
void swift_arrayInitWithTakeNoAlias(OpaqueValue *dest, OpaqueValue *src,
size_t count, const Metadata *self) {
@@ -150,7 +148,6 @@
dest, src, count, self);
}
-SWIFT_CC(c)
SWIFT_RUNTIME_EXPORT
void swift_arrayInitWithTakeFrontToBack(OpaqueValue *dest, OpaqueValue *src,
size_t count, const Metadata *self) {
@@ -158,7 +155,6 @@
ArrayCopy::FrontToBack>(dest, src, count, self);
}
-SWIFT_CC(c)
SWIFT_RUNTIME_EXPORT
void swift_arrayInitWithTakeBackToFront(OpaqueValue *dest, OpaqueValue *src,
size_t count, const Metadata *self) {
@@ -166,7 +162,6 @@
ArrayCopy::BackToFront>(dest, src, count, self);
}
-SWIFT_CC(c)
SWIFT_RUNTIME_EXPORT
void swift_arrayAssignWithCopyNoAlias(OpaqueValue *dest, OpaqueValue *src,
size_t count, const Metadata *self) {
@@ -174,7 +169,6 @@
ArrayCopy::NoAlias>(dest, src, count, self);
}
-SWIFT_CC(c)
SWIFT_RUNTIME_EXPORT
void swift_arrayAssignWithCopyFrontToBack(OpaqueValue *dest, OpaqueValue *src,
size_t count, const Metadata *self) {
@@ -182,7 +176,6 @@
ArrayCopy::FrontToBack>(dest, src, count, self);
}
-SWIFT_CC(c)
SWIFT_RUNTIME_EXPORT
void swift_arrayAssignWithCopyBackToFront(OpaqueValue *dest, OpaqueValue *src,
size_t count, const Metadata *self) {
@@ -190,7 +183,6 @@
ArrayCopy::BackToFront>(dest, src, count, self);
}
-SWIFT_CC(c)
SWIFT_RUNTIME_EXPORT
void swift_arrayAssignWithTake(OpaqueValue *dest, OpaqueValue *src,
size_t count, const Metadata *self) {
@@ -198,7 +190,6 @@
ArrayCopy::NoAlias>(dest, src, count, self);
}
-SWIFT_CC(c)
SWIFT_RUNTIME_EXPORT
void swift_arrayDestroy(OpaqueValue *begin, size_t count, const Metadata *self) {
if (count == 0)
diff --git a/stdlib/public/runtime/CMakeLists.txt b/stdlib/public/runtime/CMakeLists.txt
index 08ae964..e9c1ee8 100644
--- a/stdlib/public/runtime/CMakeLists.txt
+++ b/stdlib/public/runtime/CMakeLists.txt
@@ -62,7 +62,6 @@
Portability.cpp
ProtocolConformance.cpp
RefCount.cpp
- RuntimeEntrySymbols.cpp
RuntimeInvocationsTracking.cpp
"${SWIFT_SOURCE_DIR}/lib/Demangling/OldDemangler.cpp"
"${SWIFT_SOURCE_DIR}/lib/Demangling/Demangler.cpp"
diff --git a/stdlib/public/runtime/Casting.cpp b/stdlib/public/runtime/Casting.cpp
index 1c46897..b877ab4 100644
--- a/stdlib/public/runtime/Casting.cpp
+++ b/stdlib/public/runtime/Casting.cpp
@@ -266,8 +266,7 @@
/// Dynamically cast a class instance to a Swift class type.
const void *swift::swift_dynamicCastClass(const void *object,
- const ClassMetadata *targetType)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+ const ClassMetadata *targetType) {
#if SWIFT_OBJC_INTEROP
assert(!targetType->isPureObjC());
@@ -567,7 +566,7 @@
}
#if SWIFT_OBJC_INTEROP
-SWIFT_CC(c) SWIFT_RUNTIME_EXPORT
+SWIFT_RUNTIME_EXPORT
id
swift_dynamicCastMetatypeToObjectConditional(const Metadata *metatype) {
switch (metatype->getKind()) {
@@ -595,7 +594,7 @@
}
}
-SWIFT_CC(c) SWIFT_RUNTIME_EXPORT
+SWIFT_RUNTIME_EXPORT
id
swift_dynamicCastMetatypeToObjectUnconditional(const Metadata *metatype) {
switch (metatype->getKind()) {
@@ -2403,8 +2402,7 @@
bool swift::swift_dynamicCast(OpaqueValue *dest, OpaqueValue *src,
const Metadata *srcType,
const Metadata *targetType,
- DynamicCastFlags flags)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+ DynamicCastFlags flags) {
auto unwrapResult = checkDynamicCastFromOptional(dest, src, srcType,
targetType, flags);
srcType = unwrapResult.payloadType;
@@ -3235,13 +3233,13 @@
}
// Called by compiler-generated cast code.
-SWIFT_CC(c) SWIFT_RUNTIME_STDLIB_API
+SWIFT_RUNTIME_STDLIB_API
bool swift_isClassType(const Metadata *type) {
return Metadata::isAnyKindOfClass(type->getKind());
}
// Called by compiler-generated code.
-SWIFT_CC(c) SWIFT_RUNTIME_STDLIB_API
+SWIFT_RUNTIME_STDLIB_API
bool swift_isOptionalType(const Metadata *type) {
return type->getKind() == MetadataKind::Optional;
}
diff --git a/stdlib/public/runtime/Enum.cpp b/stdlib/public/runtime/Enum.cpp
index e547848..e69e47f 100644
--- a/stdlib/public/runtime/Enum.cpp
+++ b/stdlib/public/runtime/Enum.cpp
@@ -133,8 +133,7 @@
int swift::swift_getEnumCaseSinglePayload(const OpaqueValue *value,
const Metadata *payload,
- unsigned emptyCases)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+ unsigned emptyCases) {
auto *payloadWitnesses = payload->getValueWitnesses();
auto size = payloadWitnesses->getSize();
@@ -150,8 +149,7 @@
void swift::swift_storeEnumTagSinglePayload(OpaqueValue *value,
const Metadata *payload,
- int whichCase, unsigned emptyCases)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+ int whichCase, unsigned emptyCases){
auto *payloadWitnesses = payload->getValueWitnesses();
auto size = payloadWitnesses->getSize();
diff --git a/stdlib/public/runtime/ErrorObject.mm b/stdlib/public/runtime/ErrorObject.mm
index 5163e27..7d2cb21 100644
--- a/stdlib/public/runtime/ErrorObject.mm
+++ b/stdlib/public/runtime/ErrorObject.mm
@@ -382,10 +382,13 @@
reinterpret_cast<GetDefaultFn*> (dlsym(RTLD_DEFAULT,
MANGLE_AS_STRING(MANGLE_SYM(10Foundation24_getErrorDefaultUserInfoyyXlSgxs0C0RzlF)))));
if (!foundationGetDefaultUserInfo) {
- T->vw_destroy(error);
+ SWIFT_CC_PLUSONE_GUARD(T->vw_destroy(error));
return nullptr;
}
+ // +0 Convention: In the case where we have the +1 convention, this will
+ // destroy the error for us, otherwise, it will take the value guaranteed. The
+ // conclusion is that we can leave this alone.
return foundationGetDefaultUserInfo(error, T, Error);
}
diff --git a/stdlib/public/runtime/Heap.cpp b/stdlib/public/runtime/Heap.cpp
index e7d2b12..90bd56a 100644
--- a/stdlib/public/runtime/Heap.cpp
+++ b/stdlib/public/runtime/Heap.cpp
@@ -22,15 +22,13 @@
using namespace swift;
-void *swift::swift_slowAlloc(size_t size, size_t alignMask)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+void *swift::swift_slowAlloc(size_t size, size_t alignMask) {
// FIXME: use posix_memalign if alignMask is larger than the system guarantee.
void *p = malloc(size);
if (!p) swift::crash("Could not allocate memory.");
return p;
}
-void swift::swift_slowDealloc(void *ptr, size_t bytes, size_t alignMask)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+void swift::swift_slowDealloc(void *ptr, size_t bytes, size_t alignMask) {
free(ptr);
}
diff --git a/stdlib/public/runtime/HeapObject.cpp b/stdlib/public/runtime/HeapObject.cpp
index fa24f1a..f7a0d66 100644
--- a/stdlib/public/runtime/HeapObject.cpp
+++ b/stdlib/public/runtime/HeapObject.cpp
@@ -27,6 +27,7 @@
#include "RuntimeInvocationsTracking.h"
#include "WeakReference.h"
#include "swift/Runtime/Debug.h"
+#include "swift/Runtime/InstrumentsSupport.h"
#include <algorithm>
#include <cassert>
#include <cstring>
@@ -40,7 +41,7 @@
# include <objc/runtime.h>
# include <objc/message.h>
# include <objc/objc.h>
-#include "swift/Runtime/ObjCBridge.h"
+# include "swift/Runtime/ObjCBridge.h"
#endif
#include "Leaks.h"
@@ -76,23 +77,16 @@
HeapObject *swift::swift_allocObject(HeapMetadata const *metadata,
size_t requiredSize,
- size_t requiredAlignmentMask)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
- return SWIFT_RT_ENTRY_REF(swift_allocObject)(metadata, requiredSize,
- requiredAlignmentMask);
+ size_t requiredAlignmentMask) {
+ return _swift_allocObject(metadata, requiredSize, requiredAlignmentMask);
}
-SWIFT_RT_ENTRY_IMPL_VISIBILITY
-extern "C"
-HeapObject *
-SWIFT_RT_ENTRY_IMPL(swift_allocObject)(HeapMetadata const *metadata,
+static HeapObject *_swift_allocObject_(HeapMetadata const *metadata,
size_t requiredSize,
- size_t requiredAlignmentMask)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+ size_t requiredAlignmentMask) {
assert(isAlignmentMask(requiredAlignmentMask));
auto object = reinterpret_cast<HeapObject *>(
- SWIFT_RT_ENTRY_CALL(swift_slowAlloc)(requiredSize,
- requiredAlignmentMask));
+ swift_slowAlloc(requiredSize, requiredAlignmentMask));
// FIXME: this should be a placement new but that adds a null check
object->metadata = metadata;
object->refCounts.init();
@@ -105,6 +99,8 @@
return object;
}
+auto swift::_swift_allocObject = _swift_allocObject_;
+
HeapObject *
swift::swift_initStackObject(HeapMetadata const *metadata,
HeapObject *object) {
@@ -163,18 +159,13 @@
/// \brief Allocate a reference-counted object on the heap that
/// occupies <size> bytes of maximally-aligned storage. The object is
/// uninitialized except for its header.
-SWIFT_CC(swift)
-SWIFT_RUNTIME_EXPORT
+SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_INTERNAL
HeapObject* swift_bufferAllocate(
HeapMetadata const* bufferType, size_t size, size_t alignMask)
{
- return swift::SWIFT_RT_ENTRY_CALL(swift_allocObject)(bufferType, size,
- alignMask);
+ return swift::swift_allocObject(bufferType, size, alignMask);
}
-SWIFT_RUNTIME_EXPORT
-intptr_t swift_bufferHeaderSize() { return sizeof(HeapObject); }
-
namespace {
/// Heap object destructor for a generic box allocated with swift_allocBox.
static SWIFT_CC(swift) void destroyGenericBox(SWIFT_CONTEXT HeapObject *o) {
@@ -184,8 +175,8 @@
metadata->BoxedType->vw_destroy(value);
// Deallocate the box.
- SWIFT_RT_ENTRY_CALL(swift_deallocObject) (o, metadata->getAllocSize(),
- metadata->getAllocAlignMask());
+ swift_deallocObject(o, metadata->getAllocSize(),
+ metadata->getAllocAlignMask());
}
class BoxCacheEntry {
@@ -219,10 +210,6 @@
static SimpleGlobalCache<BoxCacheEntry> Boxes;
-BoxPair::Return swift::swift_allocBox(const Metadata *type) {
- return SWIFT_RT_ENTRY_REF(swift_allocBox)(type);
-}
-
BoxPair::Return swift::swift_makeBoxUnique(OpaqueValue *buffer, const Metadata *type,
size_t alignMask) {
auto *inlineBuffer = reinterpret_cast<ValueBuffer*>(buffer);
@@ -248,26 +235,30 @@
}
}
-SWIFT_RT_ENTRY_IMPL_VISIBILITY
-extern "C"
-BoxPair::Return SWIFT_RT_ENTRY_IMPL(swift_allocBox)(const Metadata *type) {
+BoxPair::Return swift::swift_allocBox(const Metadata *type) {
+ return _swift_allocBox(type);
+}
+
+static BoxPair::Return _swift_allocBox_(const Metadata *type) {
// Get the heap metadata for the box.
auto metadata = &Boxes.getOrInsert(type).first->Data;
// Allocate and project the box.
- auto allocation = SWIFT_RT_ENTRY_CALL(swift_allocObject)(
- metadata, metadata->getAllocSize(), metadata->getAllocAlignMask());
+ auto allocation = swift_allocObject(metadata, metadata->getAllocSize(),
+ metadata->getAllocAlignMask());
auto projection = metadata->project(allocation);
return BoxPair{allocation, projection};
}
+auto swift::_swift_allocBox = _swift_allocBox_;
+
void swift::swift_deallocBox(HeapObject *o) {
auto metadata = static_cast<const GenericBoxHeapMetadata *>(o->metadata);
// Move the object to the deallocating state (+1 -> +0).
o->refCounts.decrementFromOneNonAtomic();
- SWIFT_RT_ENTRY_CALL(swift_deallocObject)(o, metadata->getAllocSize(),
- metadata->getAllocAlignMask());
+ swift_deallocObject(o, metadata->getAllocSize(),
+ metadata->getAllocAlignMask());
}
OpaqueValue *swift::swift_projectBox(HeapObject *o) {
@@ -300,126 +291,85 @@
HeapObject *swift::swift_allocEmptyBox() {
auto heapObject = reinterpret_cast<HeapObject*>(&_EmptyBoxStorage);
- SWIFT_RT_ENTRY_CALL(swift_retain)(heapObject);
+ swift_retain(heapObject);
return heapObject;
}
// Forward-declare this, but define it after swift_release.
extern "C" LLVM_LIBRARY_VISIBILITY LLVM_ATTRIBUTE_NOINLINE LLVM_ATTRIBUTE_USED
-void _swift_release_dealloc(HeapObject *object) SWIFT_CC(RegisterPreservingCC_IMPL);
+void _swift_release_dealloc(HeapObject *object);
-HeapObject *swift::swift_retain(HeapObject *object)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
- return SWIFT_RT_ENTRY_REF(swift_retain)(object);
+HeapObject *swift::swift_retain(HeapObject *object) {
+ return _swift_retain(object);
}
-HeapObject *swift::swift_nonatomic_retain(HeapObject *object) {
- return SWIFT_RT_ENTRY_REF(swift_nonatomic_retain)(object);
-}
-
-SWIFT_RT_ENTRY_IMPL_VISIBILITY
-extern "C" HeapObject *
-SWIFT_RT_ENTRY_IMPL(swift_nonatomic_retain)(HeapObject *object) {
- SWIFT_RT_TRACK_INVOCATION(object, swift_nonatomic_retain);
- if (isValidPointerForNativeRetain(object))
- object->refCounts.incrementNonAtomic(1);
- return object;
-}
-
-void swift::swift_nonatomic_release(HeapObject *object) {
- return SWIFT_RT_ENTRY_REF(swift_nonatomic_release)(object);
-}
-
-SWIFT_RT_ENTRY_IMPL_VISIBILITY
-extern "C"
-void SWIFT_RT_ENTRY_IMPL(swift_nonatomic_release)(HeapObject *object) {
- SWIFT_RT_TRACK_INVOCATION(object, swift_nonatomic_release);
- if (isValidPointerForNativeRetain(object))
- object->refCounts.decrementAndMaybeDeinitNonAtomic(1);
-}
-
-SWIFT_RT_ENTRY_IMPL_VISIBILITY
-extern "C"
-HeapObject *SWIFT_RT_ENTRY_IMPL(swift_retain)(HeapObject *object)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+static HeapObject *_swift_retain_(HeapObject *object) {
SWIFT_RT_TRACK_INVOCATION(object, swift_retain);
if (isValidPointerForNativeRetain(object))
object->refCounts.increment(1);
return object;
}
-HeapObject *swift::swift_retain_n(HeapObject *object, uint32_t n)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
- return SWIFT_RT_ENTRY_REF(swift_retain_n)(object, n);
+auto swift::_swift_retain = _swift_retain_;
+
+HeapObject *swift::swift_nonatomic_retain(HeapObject *object) {
+ SWIFT_RT_TRACK_INVOCATION(object, swift_nonatomic_retain);
+ if (isValidPointerForNativeRetain(object))
+ object->refCounts.incrementNonAtomic(1);
+ return object;
}
-SWIFT_RT_ENTRY_IMPL_VISIBILITY
-extern "C"
-HeapObject *SWIFT_RT_ENTRY_IMPL(swift_retain_n)(HeapObject *object, uint32_t n)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+HeapObject *swift::swift_retain_n(HeapObject *object, uint32_t n) {
+ return _swift_retain_n(object, n);
+}
+
+static HeapObject *_swift_retain_n_(HeapObject *object, uint32_t n) {
SWIFT_RT_TRACK_INVOCATION(object, swift_retain_n);
if (isValidPointerForNativeRetain(object))
object->refCounts.increment(n);
return object;
}
-HeapObject *swift::swift_nonatomic_retain_n(HeapObject *object, uint32_t n)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
- return SWIFT_RT_ENTRY_REF(swift_nonatomic_retain_n)(object, n);
-}
+auto swift::_swift_retain_n = _swift_retain_n_;
-SWIFT_RT_ENTRY_IMPL_VISIBILITY
-extern "C" HeapObject *
-SWIFT_RT_ENTRY_IMPL(swift_nonatomic_retain_n)(HeapObject *object, uint32_t n)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+HeapObject *swift::swift_nonatomic_retain_n(HeapObject *object, uint32_t n) {
SWIFT_RT_TRACK_INVOCATION(object, swift_nonatomic_retain_n);
if (isValidPointerForNativeRetain(object))
object->refCounts.incrementNonAtomic(n);
return object;
}
-void swift::swift_release(HeapObject *object)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
- SWIFT_RT_ENTRY_REF(swift_release)(object);
+void swift::swift_release(HeapObject *object) {
+ _swift_release(object);
}
-SWIFT_RT_ENTRY_IMPL_VISIBILITY
-extern "C"
-void SWIFT_RT_ENTRY_IMPL(swift_release)(HeapObject *object)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+static void _swift_release_(HeapObject *object) {
SWIFT_RT_TRACK_INVOCATION(object, swift_release);
if (isValidPointerForNativeRetain(object))
object->refCounts.decrementAndMaybeDeinit(1);
}
-void swift::swift_release_n(HeapObject *object, uint32_t n)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
- return SWIFT_RT_ENTRY_REF(swift_release_n)(object, n);
+auto swift::_swift_release = _swift_release_;
+
+void swift::swift_nonatomic_release(HeapObject *object) {
+ SWIFT_RT_TRACK_INVOCATION(object, swift_nonatomic_release);
+ if (isValidPointerForNativeRetain(object))
+ object->refCounts.decrementAndMaybeDeinitNonAtomic(1);
}
-SWIFT_RT_ENTRY_IMPL_VISIBILITY
-extern "C"
-void SWIFT_RT_ENTRY_IMPL(swift_release_n)(HeapObject *object, uint32_t n)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+void swift::swift_release_n(HeapObject *object, uint32_t n) {
+ return _swift_release_n(object, n);
+}
+
+static void _swift_release_n_(HeapObject *object, uint32_t n) {
SWIFT_RT_TRACK_INVOCATION(object, swift_release_n);
if (isValidPointerForNativeRetain(object))
object->refCounts.decrementAndMaybeDeinit(n);
}
-void swift::swift_setDeallocating(HeapObject *object) {
- SWIFT_RT_TRACK_INVOCATION(object, swift_setDeallocating);
- object->refCounts.decrementFromOneNonAtomic();
-}
+auto swift::_swift_release_n = _swift_release_n_;
-void swift::swift_nonatomic_release_n(HeapObject *object, uint32_t n)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
- return SWIFT_RT_ENTRY_REF(swift_nonatomic_release_n)(object, n);
-}
-
-SWIFT_RT_ENTRY_IMPL_VISIBILITY
-extern "C"
-void SWIFT_RT_ENTRY_IMPL(swift_nonatomic_release_n)(HeapObject *object, uint32_t n)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+void swift::swift_nonatomic_release_n(HeapObject *object, uint32_t n) {
SWIFT_RT_TRACK_INVOCATION(object, swift_nonatomic_release_n);
if (isValidPointerForNativeRetain(object))
object->refCounts.decrementAndMaybeDeinitNonAtomic(n);
@@ -433,8 +383,7 @@
return object->refCounts.getUnownedCount();
}
-HeapObject *swift::swift_unownedRetain(HeapObject *object)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+HeapObject *swift::swift_unownedRetain(HeapObject *object) {
SWIFT_RT_TRACK_INVOCATION(object, swift_unownedRetain);
if (!isValidPointerForNativeRetain(object))
return object;
@@ -443,8 +392,7 @@
return object;
}
-void swift::swift_unownedRelease(HeapObject *object)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+void swift::swift_unownedRelease(HeapObject *object) {
SWIFT_RT_TRACK_INVOCATION(object, swift_unownedRelease);
if (!isValidPointerForNativeRetain(object))
return;
@@ -456,14 +404,12 @@
if (object->refCounts.decrementUnownedShouldFree(1)) {
auto classMetadata = static_cast<const ClassMetadata*>(object->metadata);
- SWIFT_RT_ENTRY_CALL(swift_slowDealloc)
- (object, classMetadata->getInstanceSize(),
- classMetadata->getInstanceAlignMask());
+ swift_slowDealloc(object, classMetadata->getInstanceSize(),
+ classMetadata->getInstanceAlignMask());
}
}
-void *swift::swift_nonatomic_unownedRetain(HeapObject *object)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+void *swift::swift_nonatomic_unownedRetain(HeapObject *object) {
SWIFT_RT_TRACK_INVOCATION(object, swift_nonatomic_unownedRetain);
if (!isValidPointerForNativeRetain(object))
return object;
@@ -472,8 +418,7 @@
return object;
}
-void swift::swift_nonatomic_unownedRelease(HeapObject *object)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+void swift::swift_nonatomic_unownedRelease(HeapObject *object) {
SWIFT_RT_TRACK_INVOCATION(object, swift_nonatomic_unownedRelease);
if (!isValidPointerForNativeRetain(object))
return;
@@ -485,14 +430,12 @@
if (object->refCounts.decrementUnownedShouldFreeNonAtomic(1)) {
auto classMetadata = static_cast<const ClassMetadata*>(object->metadata);
- SWIFT_RT_ENTRY_CALL(swift_slowDealloc)
- (object, classMetadata->getInstanceSize(),
- classMetadata->getInstanceAlignMask());
+ swift_slowDealloc(object, classMetadata->getInstanceSize(),
+ classMetadata->getInstanceAlignMask());
}
}
-HeapObject *swift::swift_unownedRetain_n(HeapObject *object, int n)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+HeapObject *swift::swift_unownedRetain_n(HeapObject *object, int n) {
SWIFT_RT_TRACK_INVOCATION(object, swift_unownedRetain_n);
if (!isValidPointerForNativeRetain(object))
return object;
@@ -501,8 +444,7 @@
return object;
}
-void swift::swift_unownedRelease_n(HeapObject *object, int n)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+void swift::swift_unownedRelease_n(HeapObject *object, int n) {
SWIFT_RT_TRACK_INVOCATION(object, swift_unownedRelease_n);
if (!isValidPointerForNativeRetain(object))
return;
@@ -513,14 +455,12 @@
if (object->refCounts.decrementUnownedShouldFree(n)) {
auto classMetadata = static_cast<const ClassMetadata*>(object->metadata);
- SWIFT_RT_ENTRY_CALL(swift_slowDealloc)
- (object, classMetadata->getInstanceSize(),
- classMetadata->getInstanceAlignMask());
+ swift_slowDealloc(object, classMetadata->getInstanceSize(),
+ classMetadata->getInstanceAlignMask());
}
}
-HeapObject *swift::swift_nonatomic_unownedRetain_n(HeapObject *object, int n)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+HeapObject *swift::swift_nonatomic_unownedRetain_n(HeapObject *object, int n) {
SWIFT_RT_TRACK_INVOCATION(object, swift_nonatomic_unownedRetain_n);
if (!isValidPointerForNativeRetain(object))
return object;
@@ -529,8 +469,7 @@
return object;
}
-void swift::swift_nonatomic_unownedRelease_n(HeapObject *object, int n)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+void swift::swift_nonatomic_unownedRelease_n(HeapObject *object, int n) {
SWIFT_RT_TRACK_INVOCATION(object, swift_unownedRelease_n);
if (!isValidPointerForNativeRetain(object))
return;
@@ -541,14 +480,12 @@
if (object->refCounts.decrementUnownedShouldFreeNonAtomic(n)) {
auto classMetadata = static_cast<const ClassMetadata*>(object->metadata);
- SWIFT_RT_ENTRY_CALL(swift_slowDealloc)
- (object, classMetadata->getInstanceSize(),
- classMetadata->getInstanceAlignMask());
+ swift_slowDealloc(object, classMetadata->getInstanceSize(),
+ classMetadata->getInstanceAlignMask());
}
}
-HeapObject *swift::swift_tryPin(HeapObject *object)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+HeapObject *swift::swift_tryPin(HeapObject *object) {
SWIFT_RT_TRACK_INVOCATION(object, swift_tryPin);
assert(isValidPointerForNativeRetain(object));
@@ -562,20 +499,13 @@
return nullptr;
}
-void swift::swift_unpin(HeapObject *object)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+void swift::swift_unpin(HeapObject *object) {
SWIFT_RT_TRACK_INVOCATION(object, swift_unpin);
if (isValidPointerForNativeRetain(object))
object->refCounts.decrementAndUnpinAndMaybeDeinit();
}
-HeapObject *swift::swift_tryRetain(HeapObject *object)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
- return SWIFT_RT_ENTRY_REF(swift_tryRetain)(object);
-}
-
-HeapObject *swift::swift_nonatomic_tryPin(HeapObject *object)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+HeapObject *swift::swift_nonatomic_tryPin(HeapObject *object) {
SWIFT_RT_TRACK_INVOCATION(object, swift_nonatomic_tryPin);
assert(object);
@@ -589,17 +519,17 @@
return nullptr;
}
-void swift::swift_nonatomic_unpin(HeapObject *object)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+void swift::swift_nonatomic_unpin(HeapObject *object) {
SWIFT_RT_TRACK_INVOCATION(object, swift_nonatomic_unpin);
if (isValidPointerForNativeRetain(object))
object->refCounts.decrementAndUnpinAndMaybeDeinitNonAtomic();
}
-SWIFT_RT_ENTRY_IMPL_VISIBILITY
-extern "C"
-HeapObject *SWIFT_RT_ENTRY_IMPL(swift_tryRetain)(HeapObject *object)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+HeapObject *swift::swift_tryRetain(HeapObject *object) {
+ return _swift_tryRetain(object);
+}
+
+static HeapObject *_swift_tryRetain_(HeapObject *object) {
SWIFT_RT_TRACK_INVOCATION(object, swift_tryRetain);
if (!isValidPointerForNativeRetain(object))
return nullptr;
@@ -608,21 +538,20 @@
else return nullptr;
}
-SWIFT_RUNTIME_EXPORT
-bool swift_isDeallocating(HeapObject *object) {
- return SWIFT_RT_ENTRY_REF(swift_isDeallocating)(object);
-}
+auto swift::_swift_tryRetain = _swift_tryRetain_;
-SWIFT_RT_ENTRY_IMPL_VISIBILITY
-extern "C"
-bool SWIFT_RT_ENTRY_IMPL(swift_isDeallocating)(HeapObject *object) {
+bool swift::swift_isDeallocating(HeapObject *object) {
if (!isValidPointerForNativeRetain(object))
return false;
return object->refCounts.isDeiniting();
}
-HeapObject *swift::swift_unownedRetainStrong(HeapObject *object)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+void swift::swift_setDeallocating(HeapObject *object) {
+ SWIFT_RT_TRACK_INVOCATION(object, swift_setDeallocating);
+ object->refCounts.decrementFromOneNonAtomic();
+}
+
+HeapObject *swift::swift_unownedRetainStrong(HeapObject *object) {
SWIFT_RT_TRACK_INVOCATION(object, swift_unownedRetainStrong);
if (!isValidPointerForNativeRetain(object))
return object;
@@ -634,8 +563,7 @@
return object;
}
-HeapObject *swift::swift_nonatomic_unownedRetainStrong(HeapObject *object)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+HeapObject *swift::swift_nonatomic_unownedRetainStrong(HeapObject *object) {
SWIFT_RT_TRACK_INVOCATION(object, swift_nonatomic_unownedRetainStrong);
if (!isValidPointerForNativeRetain(object))
return object;
@@ -647,8 +575,7 @@
return object;
}
-void swift::swift_unownedRetainStrongAndRelease(HeapObject *object)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+void swift::swift_unownedRetainStrongAndRelease(HeapObject *object) {
SWIFT_RT_TRACK_INVOCATION(object, swift_unownedRetainStrongAndRelease);
if (!isValidPointerForNativeRetain(object))
return;
@@ -664,8 +591,7 @@
(void) dealloc;
}
-void swift::swift_nonatomic_unownedRetainStrongAndRelease(HeapObject *object)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+void swift::swift_nonatomic_unownedRetainStrongAndRelease(HeapObject *object) {
SWIFT_RT_TRACK_INVOCATION(object, swift_nonatomic_unownedRetainStrongAndRelease);
if (!isValidPointerForNativeRetain(object))
return;
@@ -690,9 +616,7 @@
swift::swift_abortRetainUnowned(object);
}
-// Declared extern "C" LLVM_LIBRARY_VISIBILITY in RefCount.h
-void _swift_release_dealloc(HeapObject *object)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+void _swift_release_dealloc(HeapObject *object) {
asFullMetadata(object->metadata)->destroy(object);
}
@@ -716,17 +640,14 @@
// references associated with this object.
objc_destructInstance((id)object);
#endif
- SWIFT_RT_ENTRY_CALL(swift_deallocObject)
- (object, allocatedSize,
- allocatedAlignMask);
+ swift_deallocObject(object, allocatedSize, allocatedAlignMask);
}
/// Variant of the above used in constructor failure paths.
-SWIFT_RUNTIME_EXPORT
-void swift_deallocPartialClassInstance(HeapObject *object,
- HeapMetadata const *metadata,
- size_t allocatedSize,
- size_t allocatedAlignMask) {
+void swift::swift_deallocPartialClassInstance(HeapObject *object,
+ HeapMetadata const *metadata,
+ size_t allocatedSize,
+ size_t allocatedAlignMask) {
if (!object)
return;
@@ -885,12 +806,10 @@
if (object->refCounts.canBeFreedNow()) {
// object state DEINITING -> DEAD
- SWIFT_RT_ENTRY_CALL(swift_slowDealloc)
- (object, allocatedSize,
- allocatedAlignMask);
+ swift_slowDealloc(object, allocatedSize, allocatedAlignMask);
} else {
// object state DEINITING -> DEINITED
- SWIFT_RT_ENTRY_CALL(swift_unownedRelease)(object);
+ swift_unownedRelease(object);
}
}
diff --git a/stdlib/public/runtime/Metadata.cpp b/stdlib/public/runtime/Metadata.cpp
index 1e40561..1bc22a9 100644
--- a/stdlib/public/runtime/Metadata.cpp
+++ b/stdlib/public/runtime/Metadata.cpp
@@ -225,8 +225,7 @@
/// The primary entrypoint.
const Metadata *swift::swift_getGenericMetadata(GenericMetadata *pattern,
- const void *arguments)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+ const void *arguments) {
auto genericArgs = (const void * const *) arguments;
size_t numGenericArgs = pattern->NumKeyArguments;
@@ -2373,8 +2372,7 @@
ProtocolClassConstraint classConstraint,
const Metadata *superclassConstraint,
size_t numProtocols,
- const ProtocolDescriptor * const *protocols)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+ const ProtocolDescriptor * const *protocols) {
// We entrust that the compiler emitting the call to
// swift_getExistentialTypeMetadata always sorts the `protocols` array using
@@ -2823,7 +2821,7 @@
const WitnessTable *swift::swift_getGenericWitnessTable(
GenericWitnessTable *genericTable, const Metadata *type,
- void *const *instantiationArgs) SWIFT_CC(RegisterPreservingCC_IMPL) {
+ void *const *instantiationArgs) {
if (doesNotRequireInstantiation(genericTable)) {
return genericTable->Pattern;
}
diff --git a/stdlib/public/runtime/Reflection.mm b/stdlib/public/runtime/Reflection.mm
index d49fc4e..14d613e 100644
--- a/stdlib/public/runtime/Reflection.mm
+++ b/stdlib/public/runtime/Reflection.mm
@@ -356,9 +356,7 @@
const OpaqueValue *value,
const Metadata *type) {
auto Tuple = static_cast<const TupleTypeMetadata *>(type);
-#ifndef SWIFT_RUNTIME_ENABLE_GUARANTEED_NORMAL_ARGUMENTS
- swift_release(owner);
-#endif
+ SWIFT_CC_PLUSONE_GUARD(swift_release(owner));
return Tuple->NumElements;
}
@@ -404,9 +402,9 @@
auto bytes = reinterpret_cast<const char*>(value);
auto eltData = reinterpret_cast<const OpaqueValue *>(bytes + elt.Offset);
-#ifdef SWIFT_RUNTIME_ENABLE_GUARANTEED_NORMAL_ARGUMENTS
- swift_retain(owner);
-#endif
+ // Since 'owner' is consumed, when we have a +0 convention, we must retain
+ // owner first.
+ SWIFT_CC_PLUSZERO_GUARD(swift_retain(owner));
// 'owner' is consumed by this call.
new (outMirror) Mirror(reflect(owner, eltData, elt.Type));
@@ -496,9 +494,7 @@
const OpaqueValue *value,
const Metadata *type) {
auto Struct = static_cast<const StructMetadata *>(type);
-#ifndef SWIFT_RUNTIME_ENABLE_GUARANTEED_NORMAL_ARGUMENTS
- swift_release(owner);
-#endif
+ SWIFT_CC_PLUSONE_GUARD(swift_release(owner));
return Struct->Description->Struct.NumFields;
}
@@ -524,6 +520,8 @@
new (outString) String(getFieldName(Struct->Description->Struct.FieldNames, i));
// 'owner' is consumed by this call.
+ SWIFT_CC_PLUSZERO_GUARD(swift_unknownRetain(owner));
+
assert(!fieldType.isIndirect() && "indirect struct fields not implemented");
if (loadSpecialReferenceStorage(owner, fieldData, fieldType, outMirror))
@@ -583,9 +581,7 @@
const OpaqueValue *value,
const Metadata *type) {
if (!isEnumReflectable(type)) {
-#ifndef SWIFT_RUNTIME_ENABLE_GUARANTEED_NORMAL_ARGUMENTS
- swift_release(owner);
-#endif
+ SWIFT_CC_PLUSONE_GUARD(swift_release(owner));
return nullptr;
}
@@ -595,9 +591,7 @@
unsigned tag;
getEnumMirrorInfo(value, type, &tag, nullptr, nullptr);
-#ifndef SWIFT_RUNTIME_ENABLE_GUARANTEED_NORMAL_ARGUMENTS
- swift_release(owner);
-#endif
+ SWIFT_CC_PLUSONE_GUARD(swift_release(owner));
return getFieldName(Description.CaseNames, tag);
}
@@ -612,12 +606,8 @@
OpaqueValue *mirrorValue = const_cast<OpaqueValue*>(cMirrorValue);
Mirror mirror;
- bool take =
-#ifndef SWIFT_RUNTIME_ENABLE_GUARANTEED_NORMAL_ARGUMENTS
- mirrorValue == value;
-#else
- false;
-#endif
+ bool take = false;
+ SWIFT_CC_PLUSONE_GUARD(take = (mirrorValue == value));
::new (&mirror) MagicMirror(mirrorValue, mirrorType, take);
@@ -625,11 +615,9 @@
MagicMirrorData data = theMirror->Data;
const char *result = swift_EnumMirror_caseName(data.Owner, data.Value, data.Type);
-#ifndef SWIFT_RUNTIME_ENABLE_GUARANTEED_NORMAL_ARGUMENTS
// Destroy the whole original value if we couldn't take it.
if (!take)
type->vw_destroy(value);
-#endif
return result;
}
@@ -639,17 +627,13 @@
const OpaqueValue *value,
const Metadata *type) {
if (!isEnumReflectable(type)) {
-#ifndef SWIFT_RUNTIME_ENABLE_GUARANTEED_NORMAL_ARGUMENTS
- swift_release(owner);
-#endif
+ SWIFT_CC_PLUSONE_GUARD(swift_release(owner));
return 0;
}
const Metadata *payloadType;
getEnumMirrorInfo(value, type, nullptr, &payloadType, nullptr);
-#ifndef SWIFT_RUNTIME_ENABLE_GUARANTEED_NORMAL_ARGUMENTS
- swift_release(owner);
-#endif
+ SWIFT_CC_PLUSONE_GUARD(swift_release(owner));
return (payloadType != nullptr) ? 1 : 0;
}
@@ -678,9 +662,7 @@
type->vw_destructiveInjectEnumTag(const_cast<OpaqueValue *>(value),
(int) (tag - Description.getNumPayloadCases()));
-#ifndef SWIFT_RUNTIME_ENABLE_GUARANTEED_NORMAL_ARGUMENTS
- swift_release(owner);
-#endif
+ SWIFT_CC_PLUSONE_GUARD(swift_release(owner));
owner = pair.first;
value = pair.second;
@@ -708,9 +690,7 @@
const OpaqueValue *value,
const Metadata *type) {
auto Clas = static_cast<const ClassMetadata*>(type);
-#ifndef SWIFT_RUNTIME_ENABLE_GUARANTEED_NORMAL_ARGUMENTS
- swift_release(owner);
-#endif
+ SWIFT_CC_PLUSONE_GUARD(swift_release(owner));
auto count = Clas->getDescription()->Class.NumFields;
// If the class has a superclass, the superclass instance is treated as the
@@ -857,9 +837,7 @@
swift_ClassMirror_quickLookObject(HeapObject *owner, const OpaqueValue *value,
const Metadata *type) {
id object = [*reinterpret_cast<const id *>(value) retain];
-#ifndef SWIFT_RUNTIME_ENABLE_GUARANTEED_NORMAL_ARGUMENTS
- swift_release(owner);
-#endif
+ SWIFT_CC_PLUSONE_GUARD(swift_release(owner));
if ([object respondsToSelector:@selector(debugQuickLookObject)]) {
id quickLookObject = [object debugQuickLookObject];
[quickLookObject retain];
@@ -955,9 +933,7 @@
Mirror resultBuf;
MagicMirror *result = ::new (&resultBuf) MagicMirror;
-#ifdef SWIFT_RUNTIME_ENABLE_GUARANTEED_NORMAL_ARGUMENTS
- swift_retain(owner);
-#endif
+ SWIFT_CC_PLUSZERO_GUARD(swift_retain(owner));
result->Self = ClassSuperMirrorMetadata();
result->MirrorWitness = &ClassSuperMirrorWitnessTable;
@@ -978,9 +954,7 @@
Mirror resultBuf;
MagicMirror *result = ::new (&resultBuf) MagicMirror;
-#ifdef SWIFT_RUNTIME_ENABLE_GUARANTEED_NORMAL_ARGUMENTS
- swift_retain(owner);
-#endif
+ SWIFT_CC_PLUSZERO_GUARD(swift_retain(owner));
result->Self = ObjCSuperMirrorMetadata();
result->MirrorWitness = &ObjCSuperMirrorWitnessTable;
@@ -1130,19 +1104,14 @@
Mirror result;
// Take the value, unless we projected a subvalue from it. We don't want to
// deal with partial value deinitialization.
- bool take =
-#ifndef SWIFT_RUNTIME_ENABLE_GUARANTEED_NORMAL_ARGUMENTS
- mirrorValue == value;
-#else
- false;
-#endif
+ bool take = false;
+ SWIFT_CC_PLUSONE_GUARD(take = (mirrorValue == value));
::new (&result) MagicMirror(mirrorValue, mirrorType, take);
-#ifndef SWIFT_RUNTIME_ENABLE_GUARANTEED_NORMAL_ARGUMENTS
// Destroy the whole original value if we couldn't take it.
- if (!take)
+ if (!take) {
T->vw_destroy(value);
-#endif
+ }
return MirrorReturn(result);
}
diff --git a/stdlib/public/runtime/RuntimeEntrySymbols.cpp b/stdlib/public/runtime/RuntimeEntrySymbols.cpp
deleted file mode 100644
index 1e48c06..0000000
--- a/stdlib/public/runtime/RuntimeEntrySymbols.cpp
+++ /dev/null
@@ -1,87 +0,0 @@
-//===--- RuntimeEntrySymbols.cpp - Define symbols for runtime entries -----===//
-//
-// This source file is part of the Swift.org open source project
-//
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
-// Licensed under Apache License v2.0 with Runtime Library Exception
-//
-// See https://swift.org/LICENSE.txt for license information
-// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines function pointer symbols for runtime entries.
-//
-//===----------------------------------------------------------------------===//
-
-// Produce global symbols referencing runtime function implementations only for
-// those runtime entries that demand it.
-//
-// Each runtime function definition in RuntimeFunctions.def should
-// indicate if it requires a global referencing it.
-//
-// For example, all entries using the RegisterPreservingCC calling convention
-// need a global, because they are currently always invoked indirectly using a
-// client-side wrapper.
-//
-// Runtime entries using the DefaultCC calling convention do not
-// demand a global symbol by default. But they can optionally ask for it, in
-// case it is needed. For example, _swift_isDeallocating is required by
-// Instruments.
-
-#include "swift/Runtime/Config.h"
-
-// Entry points using a standard C calling convention or not using the new
-// calling convention do not need to have global symbols referring to their
-// implementations.
-#define FOR_CONV_DefaultCC(...)
-#define FOR_CONV_C_CC(...)
-
-// Entry points implemented in swift using the swift calling convention.
-#define FOR_CONV_SwiftCC(...)
-
-// Entry points using the new calling convention require global symbols
-// referring to their implementations.
-#define FOR_CONV_RegisterPreservingCC(x) x
-
-typedef void (*RuntimeEntry)();
-
-// Generate a forward declaration of the runtime entry implementation.
-// Define a global symbol referring to this implementation.
-
-#define DEFINE_SYMBOL(SymbolName, Name, CC) \
- SWIFT_RT_ENTRY_IMPL_VISIBILITY extern "C" void Name() \
- SWIFT_CC(CC); \
- SWIFT_RUNTIME_EXPORT RuntimeEntry SymbolName = \
- reinterpret_cast<RuntimeEntry>(Name);
-
-#define FUNCTION1(Id, Name, CC, ReturnTys, ArgTys, Attrs) \
- DEFINE_SYMBOL(SWIFT_RT_ENTRY_REF(Name), Name, CC)
-
-#if defined(SWIFT_RT_USE_WRAPPERS)
-// Automatically generate a global symbol name if it is required by the calling
-// convention.
-#define FUNCTION(Id, Name, CC, ReturnTys, ArgTys, Attrs) \
- FOR_CONV_##CC(FUNCTION1(Id, Name, CC, ReturnTys, ArgTys, Attrs))
-#else
-// No need to generate any global symbols for entries that do not provide their
-// own symbols.
-#define FUNCTION(Id, Name, CC, ReturnTys, ArgTys, Attrs)
-#endif
-// Allow for a custom global symbol name and implementation.
-#define FUNCTION_WITH_GLOBAL_SYMBOL_AND_IMPL(Id, Name, GlobalSymbolName, Impl, \
- CC, ReturnTys, ArgTys, Attrs) \
- DEFINE_SYMBOL(GlobalSymbolName, Impl, CC)
-
-// Indicate that we are going to generate the global symbols for those runtime
-// functions that require it.
-#define SWIFT_RUNTIME_GENERATE_GLOBAL_SYMBOLS 1
-
-namespace swift {
-// Generate global symbols which are function pointers to the actual
-// implementations of runtime entry points.
-// This is done only for entry points using a new calling convention or
-// for those entry points which explicitly require it.
-#include "swift/Runtime/RuntimeFunctions.def"
-} // namespace swift
-
diff --git a/stdlib/public/runtime/RuntimeInvocationsTracking.cpp b/stdlib/public/runtime/RuntimeInvocationsTracking.cpp
index 1a4bbde..95957758 100644
--- a/stdlib/public/runtime/RuntimeInvocationsTracking.cpp
+++ b/stdlib/public/runtime/RuntimeInvocationsTracking.cpp
@@ -21,10 +21,7 @@
#include "swift/Runtime/HeapObject.h"
#include "swift/Runtime/Mutex.h"
-// This file is compiled always, even if assertions are disabled and no runtime
-// functions are being tracked. This is done to avoid recompiling Swift clients
-// using these APIs. They should be able to link against the standard library
-// independent of the fact whether assertions are enabled or not.
+#if defined(SWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS)
#define SWIFT_RT_FUNCTION_INVOCATION_COUNTER_NAME(RT_FUNCTION) \
invocationCounter_##RT_FUNCTION
@@ -238,3 +235,5 @@
/// TODO: Provide an API to remove any counters releated to a specific object
/// or all objects.
/// This is useful if you want to reset the stats for some/all objects.
+
+#endif
diff --git a/stdlib/public/runtime/RuntimeInvocationsTracking.h b/stdlib/public/runtime/RuntimeInvocationsTracking.h
index f906678..74d6091 100644
--- a/stdlib/public/runtime/RuntimeInvocationsTracking.h
+++ b/stdlib/public/runtime/RuntimeInvocationsTracking.h
@@ -20,6 +20,9 @@
#include "swift/Runtime/Config.h"
+/// This API is only enabled if this define is set.
+#if defined(SWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS)
+
#if defined(__cplusplus)
namespace swift {
@@ -39,10 +42,6 @@
#define SWIFT_RT_TRACK_INVOCATION_NAME(RT_FUNCTION) \
swift_trackRuntimeInvocation_##RT_FUNCTION
-/// Instrument the runtime functions only if we are building with
-/// assertions enabled.
-#if !defined(NDEBUG)
-
/// Invoke a helper function for tracking the calls of a runtime function.
#define SWIFT_RT_TRACK_INVOCATION(OBJ, RT_FUNCTION) \
SWIFT_RT_TRACK_INVOCATION_NAME(RT_FUNCTION)(OBJ)
@@ -52,13 +51,6 @@
/// Declarations of external functions for invocations tracking.
#include "RuntimeInvocationsTracking.def"
-#else
-
-/// It is just a NOP if assertions are not enabled.
-#define SWIFT_RT_TRACK_INVOCATION(OBJ, RT_FUNCTION)
-
-#endif // NDEBUG
-
/// This type defines a callback to be called on any intercepted runtime
/// function.
using RuntimeFunctionCountersUpdateHandler =
@@ -118,4 +110,12 @@
_swift_setGlobalRuntimeFunctionCountersUpdateHandler(
RuntimeFunctionCountersUpdateHandler handler);
+#else
+
+/// Let runtime functions unconditionally use this define by making it a NOP if
+/// counters are not enabled.
+#define SWIFT_RT_TRACK_INVOCATION(OBJ, RT_FUNCTION)
+
+#endif // SWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS
+
#endif
diff --git a/stdlib/public/runtime/SwiftObject.mm b/stdlib/public/runtime/SwiftObject.mm
index 9accc5e..ea9bdc9 100644
--- a/stdlib/public/runtime/SwiftObject.mm
+++ b/stdlib/public/runtime/SwiftObject.mm
@@ -480,8 +480,7 @@
static uintptr_t const objectPointerIsObjCBit = 0x00000002U;
#endif
-void *swift::swift_unknownRetain_n(void *object, int n)
- SWIFT_CC(DefaultCC_IMPL) {
+void *swift::swift_unknownRetain_n(void *object, int n) {
if (isObjCTaggedPointerOrNull(object)) return object;
if (objectUsesNativeSwiftReferenceCounting(object)) {
return swift_retain_n(static_cast<HeapObject *>(object), n);
@@ -492,8 +491,7 @@
return object;
}
-void swift::swift_unknownRelease_n(void *object, int n)
- SWIFT_CC(DefaultCC_IMPL) {
+void swift::swift_unknownRelease_n(void *object, int n) {
if (isObjCTaggedPointerOrNull(object)) return;
if (objectUsesNativeSwiftReferenceCounting(object))
return swift_release_n(static_cast<HeapObject *>(object), n);
@@ -501,8 +499,7 @@
objc_release(static_cast<id>(object));
}
-void *swift::swift_unknownRetain(void *object)
- SWIFT_CC(DefaultCC_IMPL) {
+void *swift::swift_unknownRetain(void *object) {
if (isObjCTaggedPointerOrNull(object)) return object;
if (objectUsesNativeSwiftReferenceCounting(object)) {
return swift_retain(static_cast<HeapObject *>(object));
@@ -510,16 +507,14 @@
return objc_retain(static_cast<id>(object));
}
-void swift::swift_unknownRelease(void *object)
- SWIFT_CC(DefaultCC_IMPL) {
+void swift::swift_unknownRelease(void *object) {
if (isObjCTaggedPointerOrNull(object)) return;
if (objectUsesNativeSwiftReferenceCounting(object))
- return SWIFT_RT_ENTRY_CALL(swift_release)(static_cast<HeapObject *>(object));
+ return swift_release(static_cast<HeapObject *>(object));
return objc_release(static_cast<id>(object));
}
-void *swift::swift_nonatomic_unknownRetain_n(void *object, int n)
- SWIFT_CC(DefaultCC_IMPL) {
+void *swift::swift_nonatomic_unknownRetain_n(void *object, int n) {
if (isObjCTaggedPointerOrNull(object)) return object;
if (objectUsesNativeSwiftReferenceCounting(object)) {
return swift_nonatomic_retain_n(static_cast<HeapObject *>(object), n);
@@ -529,8 +524,7 @@
return object;
}
-void swift::swift_nonatomic_unknownRelease_n(void *object, int n)
- SWIFT_CC(DefaultCC_IMPL) {
+void swift::swift_nonatomic_unknownRelease_n(void *object, int n) {
if (isObjCTaggedPointerOrNull(object)) return;
if (objectUsesNativeSwiftReferenceCounting(object))
return swift_nonatomic_release_n(static_cast<HeapObject *>(object), n);
@@ -538,8 +532,7 @@
objc_release(static_cast<id>(object));
}
-void *swift::swift_nonatomic_unknownRetain(void *object)
- SWIFT_CC(DefaultCC_IMPL) {
+void *swift::swift_nonatomic_unknownRetain(void *object) {
if (isObjCTaggedPointerOrNull(object)) return object;
if (objectUsesNativeSwiftReferenceCounting(object)) {
return swift_nonatomic_retain(static_cast<HeapObject *>(object));
@@ -547,11 +540,10 @@
return objc_retain(static_cast<id>(object));
}
-void swift::swift_nonatomic_unknownRelease(void *object)
- SWIFT_CC(DefaultCC_IMPL) {
+void swift::swift_nonatomic_unknownRelease(void *object) {
if (isObjCTaggedPointerOrNull(object)) return;
if (objectUsesNativeSwiftReferenceCounting(object))
- return SWIFT_RT_ENTRY_CALL(swift_release)(static_cast<HeapObject *>(object));
+ return swift_release(static_cast<HeapObject *>(object));
return objc_release(static_cast<id>(object));
}
@@ -576,8 +568,7 @@
return (void*)(uintptr_t(object) & ~unTaggedNonNativeBridgeObjectBits);
}
-void *swift::swift_bridgeObjectRetain(void *object)
- SWIFT_CC(DefaultCC_IMPL) {
+void *swift::swift_bridgeObjectRetain(void *object) {
#if SWIFT_OBJC_INTEROP
if (isObjCTaggedPointer(object))
return object;
@@ -598,8 +589,7 @@
}
SWIFT_RUNTIME_EXPORT
-void *swift::swift_nonatomic_bridgeObjectRetain(void *object)
- SWIFT_CC(DefaultCC_IMPL) {
+void *swift::swift_nonatomic_bridgeObjectRetain(void *object) {
#if SWIFT_OBJC_INTEROP
if (isObjCTaggedPointer(object))
return object;
@@ -620,8 +610,7 @@
}
SWIFT_RUNTIME_EXPORT
-void swift::swift_bridgeObjectRelease(void *object)
- SWIFT_CC(DefaultCC_IMPL) {
+void swift::swift_bridgeObjectRelease(void *object) {
#if SWIFT_OBJC_INTEROP
if (isObjCTaggedPointer(object))
return;
@@ -638,8 +627,7 @@
#endif
}
-void swift::swift_nonatomic_bridgeObjectRelease(void *object)
- SWIFT_CC(DefaultCC_IMPL) {
+void swift::swift_nonatomic_bridgeObjectRelease(void *object) {
#if SWIFT_OBJC_INTEROP
if (isObjCTaggedPointer(object))
return;
@@ -656,8 +644,7 @@
#endif
}
-void *swift::swift_bridgeObjectRetain_n(void *object, int n)
- SWIFT_CC(DefaultCC_IMPL) {
+void *swift::swift_bridgeObjectRetain_n(void *object, int n) {
#if SWIFT_OBJC_INTEROP
if (isObjCTaggedPointer(object))
return object;
@@ -680,8 +667,7 @@
#endif
}
-void swift::swift_bridgeObjectRelease_n(void *object, int n)
- SWIFT_CC(DefaultCC_IMPL) {
+void swift::swift_bridgeObjectRelease_n(void *object, int n) {
#if SWIFT_OBJC_INTEROP
if (isObjCTaggedPointer(object))
return;
@@ -699,8 +685,7 @@
#endif
}
-void *swift::swift_nonatomic_bridgeObjectRetain_n(void *object, int n)
- SWIFT_CC(DefaultCC_IMPL) {
+void *swift::swift_nonatomic_bridgeObjectRetain_n(void *object, int n) {
#if SWIFT_OBJC_INTEROP
if (isObjCTaggedPointer(object))
return object;
@@ -723,8 +708,7 @@
#endif
}
-void swift::swift_nonatomic_bridgeObjectRelease_n(void *object, int n)
- SWIFT_CC(DefaultCC_IMPL) {
+void swift::swift_nonatomic_bridgeObjectRelease_n(void *object, int n) {
#if SWIFT_OBJC_INTEROP
if (isObjCTaggedPointer(object))
return;
@@ -1248,9 +1232,7 @@
(void)registered;
}
-SWIFT_RT_ENTRY_VISIBILITY
-Class swift_getInitializedObjCClass(Class c)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+Class swift::swift_getInitializedObjCClass(Class c) {
// Used when we have class metadata and we want to ensure a class has been
// initialized by the Objective-C runtime. We need to do this because the
// class "c" might be valid metadata, but it hasn't been initialized yet.
@@ -1306,8 +1288,7 @@
}
#endif
-bool swift::swift_isUniquelyReferenced_nonNull_native(const HeapObject *object)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+bool swift::swift_isUniquelyReferenced_nonNull_native(const HeapObject *object){
assert(object != nullptr);
assert(!object->refCounts.isDeiniting());
return object->refCounts.isUniquelyReferenced();
@@ -1315,7 +1296,7 @@
bool swift::swift_isUniquelyReferenced_native(const HeapObject* object) {
return object != nullptr
- && swift::SWIFT_RT_ENTRY_CALL(swift_isUniquelyReferenced_nonNull_native)(object);
+ && swift::swift_isUniquelyReferenced_nonNull_native(object);
}
bool swift::swift_isUniquelyReferencedNonObjC_nonNull(const void* object) {
@@ -1324,8 +1305,7 @@
#if SWIFT_OBJC_INTEROP
usesNativeSwiftReferenceCounting_nonNull(object) &&
#endif
- SWIFT_RT_ENTRY_CALL(swift_isUniquelyReferenced_nonNull_native)(
- (const HeapObject*)object);
+ swift_isUniquelyReferenced_nonNull_native((const HeapObject*)object);
}
// Given an object reference, return true iff it is non-nil and refers
@@ -1354,12 +1334,11 @@
// object is going to be a negligible cost for a possible big win.
#if SWIFT_OBJC_INTEROP
return !isNonNative_unTagged_bridgeObject(bridgeObject)
- ? SWIFT_RT_ENTRY_CALL(swift_isUniquelyReferenced_nonNull_native)(
+ ? swift_isUniquelyReferenced_nonNull_native(
(const HeapObject *)object)
: swift_isUniquelyReferencedNonObjC_nonNull(object);
#else
- return SWIFT_RT_ENTRY_CALL(swift_isUniquelyReferenced_nonNull_native)(
- (const HeapObject *)object);
+ return swift_isUniquelyReferenced_nonNull_native((const HeapObject *)object);
#endif
}
@@ -1404,8 +1383,7 @@
// Given a non-@objc object reference, return true iff the
// object is non-nil and either has a strong reference count of 1
// or is pinned.
-bool swift::swift_isUniquelyReferencedOrPinned_native(const HeapObject *object)
- SWIFT_CC(RegisterPreservingCC_IMPL) {
+bool swift::swift_isUniquelyReferencedOrPinned_native(const HeapObject *object){
return object != nullptr &&
swift_isUniquelyReferencedOrPinned_nonNull_native(object);
}
@@ -1414,7 +1392,7 @@
/// either the object has a strong reference count of 1 or its
/// pinned flag is set.
bool swift::swift_isUniquelyReferencedOrPinned_nonNull_native(
- const HeapObject *object) SWIFT_CC(RegisterPreservingCC_IMPL) {
+ const HeapObject *object) {
assert(object != nullptr);
assert(!object->refCounts.isDeiniting());
return object->refCounts.isUniquelyReferencedOrPinned();
diff --git a/stdlib/public/stubs/Reflection.mm b/stdlib/public/stubs/Reflection.mm
index 68a16cc..c92e199 100644
--- a/stdlib/public/stubs/Reflection.mm
+++ b/stdlib/public/stubs/Reflection.mm
@@ -21,8 +21,8 @@
id SWIFT_NS_RELEASES_ARGUMENT _Nonnull object,
NSString *SWIFT_NS_RELEASES_ARGUMENT _Nonnull className) {
bool result = [object isKindOfClass:NSClassFromString(className)];
- [object release];
- [className release];
+ SWIFT_CC_PLUSONE_GUARD([object release]);
+ SWIFT_CC_PLUSONE_GUARD([className release]);
return result;
}
diff --git a/stdlib/public/stubs/SwiftNativeNSXXXBase.mm.gyb b/stdlib/public/stubs/SwiftNativeNSXXXBase.mm.gyb
index c427717..0642352 100644
--- a/stdlib/public/stubs/SwiftNativeNSXXXBase.mm.gyb
+++ b/stdlib/public/stubs/SwiftNativeNSXXXBase.mm.gyb
@@ -107,8 +107,8 @@
swift_stdlib_NSObject_isEqual(NSObject *SWIFT_NS_RELEASES_ARGUMENT lhs,
NSObject *SWIFT_NS_RELEASES_ARGUMENT rhs) {
bool Result = (lhs == rhs) || [lhs isEqual:rhs];
- swift_unknownRelease(lhs);
- swift_unknownRelease(rhs);
+ SWIFT_CC_PLUSONE_GUARD(swift_unknownRelease(lhs));
+ SWIFT_CC_PLUSONE_GUARD(swift_unknownRelease(rhs));
return Result;
}
@@ -118,8 +118,8 @@
// 'kCFCompareNonliteral' actually means "normalize to NFD".
int Result = CFStringCompare((__bridge CFStringRef)lhs,
(__bridge CFStringRef)rhs, kCFCompareNonliteral);
- swift_unknownRelease(lhs);
- swift_unknownRelease(rhs);
+ SWIFT_CC_PLUSONE_GUARD(swift_unknownRelease(lhs));
+ SWIFT_CC_PLUSONE_GUARD(swift_unknownRelease(rhs));
return Result;
}
@@ -152,8 +152,8 @@
(__bridge CFStringRef)theString, (__bridge CFStringRef)prefix,
CFRangeMake(0, Length), kCFCompareAnchored | kCFCompareNonliteral,
nullptr);
- swift_unknownRelease(theString);
- swift_unknownRelease(prefix);
+ SWIFT_CC_PLUSONE_GUARD(swift_unknownRelease(theString));
+ SWIFT_CC_PLUSONE_GUARD(swift_unknownRelease(prefix));
return Result;
}
@@ -177,8 +177,8 @@
(__bridge CFStringRef)theString, (__bridge CFStringRef)suffix,
CFRangeMake(0, Length),
kCFCompareAnchored | kCFCompareBackwards | kCFCompareNonliteral, nullptr);
- swift_unknownRelease(theString);
- swift_unknownRelease(suffix);
+ SWIFT_CC_PLUSONE_GUARD(swift_unknownRelease(theString));
+ SWIFT_CC_PLUSONE_GUARD(swift_unknownRelease(suffix));
return Result;
}
@@ -197,7 +197,7 @@
void swift_stdlib_CFSetGetValues(NSSet *SWIFT_NS_RELEASES_ARGUMENT set,
const void **values) {
CFSetGetValues((__bridge CFSetRef)set, values);
- swift_unknownRelease(set);
+ SWIFT_CC_PLUSONE_GUARD(swift_unknownRelease(set));
}
#endif
diff --git a/test/ClangImporter/objc_ir.swift b/test/ClangImporter/objc_ir.swift
index 43f9cb9..22b76b1 100644
--- a/test/ClangImporter/objc_ir.swift
+++ b/test/ClangImporter/objc_ir.swift
@@ -81,7 +81,7 @@
// CHECK-LABEL: define hidden swiftcc %TSo1BC* @"$S7objc_ir8downcast1aSo1BCSo1AC_tF"(
func downcast(a a: A) -> B {
// CHECK: [[CLASS:%.*]] = load %objc_class*, %objc_class** @"OBJC_CLASS_REF_$_B"
- // CHECK: [[T0:%.*]] = call %objc_class* @swift_rt_swift_getInitializedObjCClass(%objc_class* [[CLASS]])
+ // CHECK: [[T0:%.*]] = call %objc_class* @swift_getInitializedObjCClass(%objc_class* [[CLASS]])
// CHECK: [[T1:%.*]] = bitcast %objc_class* [[T0]] to i8*
// CHECK: call i8* @swift_dynamicCastObjCClassUnconditional(i8* [[A:%.*]], i8* [[T1]]) [[NOUNWIND:#[0-9]+]]
return a as! B
@@ -132,7 +132,7 @@
// CHECK: [[RAW_RESULT:%.+]] = call i8* @processComboType(i8* {{%.+}})
// CHECK: [[CASTED_RESULT:%.+]] = bitcast i8* [[RAW_RESULT]] to %objc_class*
// CHECK: [[SWIFT_RESULT:%.+]] = call %swift.type* @swift_getObjCClassMetadata(%objc_class* [[CASTED_RESULT]])
- // CHECK: call void bitcast (void (%swift.refcounted*)* @swift_rt_swift_release to void (%T7objc_ir4ImplC*)*)(%T7objc_ir4ImplC* %0)
+ // CHECK: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T7objc_ir4ImplC*)*)(%T7objc_ir4ImplC* %0)
// CHECK: ret %swift.type* [[SWIFT_RESULT]]
let type = processComboType(type(of: p))
return type
@@ -145,7 +145,7 @@
// CHECK: [[RAW_RESULT:%.+]] = call i8* @processComboType2(i8* {{%.+}})
// CHECK: [[CASTED_RESULT:%.+]] = bitcast i8* [[RAW_RESULT]] to %objc_class*
// CHECK: [[SWIFT_RESULT:%.+]] = call %swift.type* @swift_getObjCClassMetadata(%objc_class* [[CASTED_RESULT]])
- // CHECK: call void bitcast (void (%swift.refcounted*)* @swift_rt_swift_release to void (%T7objc_ir4ImplC*)*)(%T7objc_ir4ImplC* %0)
+ // CHECK: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T7objc_ir4ImplC*)*)(%T7objc_ir4ImplC* %0)
// CHECK: ret %swift.type* [[SWIFT_RESULT]]
let type = processComboType2(type(of: p))
return type
diff --git a/test/Constraints/iuo.swift b/test/Constraints/iuo.swift
index 7ae5dab..ebbea48 100644
--- a/test/Constraints/iuo.swift
+++ b/test/Constraints/iuo.swift
@@ -180,3 +180,27 @@
let _: (Bool) -> T? = id(T.iuoResultStatic as (Bool) -> T?)
let _: T! = id(T.iuoResultStatic(true))
}
+
+func takesInOutIUO(_ i: inout Int!) {}
+func takesInOutOpt(_ o: inout Int?) {}
+
+func overloadedByOptionality(_ a: inout Int!) {}
+// expected-note@-1 {{'overloadedByOptionality' previously declared here}}
+// expected-note@-2 {{'overloadedByOptionality' previously declared here}}
+func overloadedByOptionality(_ a: inout Int?) {}
+// expected-warning@-1 {{invalid redeclaration of 'overloadedByOptionality' which differs only by the kind of optional passed as an inout argument ('Int?' vs. 'Int!')}}
+// expected-warning@-2 {{invalid redeclaration of 'overloadedByOptionality' which differs only by the kind of optional passed as an inout argument ('Int?' vs. 'Int!')}}
+// expected-note@-3 {{overloading by kind of optional is deprecated and will be removed in a future release}}
+// expected-note@-4 {{overloading by kind of optional is deprecated and will be removed in a future release}}
+
+func testInOutOptionality() {
+ var i: Int! = 1
+ var o: Int? = 2
+
+ takesInOutIUO(&i)
+ takesInOutOpt(&i)
+ takesInOutIUO(&o)
+ takesInOutOpt(&o)
+
+ overloadedByOptionality(&o)
+}
diff --git a/test/DebugInfo/linetable-cleanups.swift b/test/DebugInfo/linetable-cleanups.swift
index ab8a3ff..d8b2c8e 100644
--- a/test/DebugInfo/linetable-cleanups.swift
+++ b/test/DebugInfo/linetable-cleanups.swift
@@ -27,7 +27,7 @@
// CHECK-NEXT: !dbg ![[CLEANUPS]]
// CHECK-NEXT: llvm.lifetime.end
// CHECK-NEXT: load
-// CHECK-NEXT: swift_rt_swift_release
+// CHECK-NEXT: swift_release
// CHECK-NEXT: bitcast
// CHECK-NEXT: llvm.lifetime.end
// CHECK-NEXT: ret void, !dbg ![[CLEANUPS]]
diff --git a/test/DebugInfo/linetable.swift b/test/DebugInfo/linetable.swift
index 1759c25..7c2cc4a 100644
--- a/test/DebugInfo/linetable.swift
+++ b/test/DebugInfo/linetable.swift
@@ -33,7 +33,7 @@
{
var result = my_class.do_something(x)
markUsed(result)
-// CHECK: call {{.*}} @swift_rt_swift_release {{.*}}
+// CHECK: call {{.*}} @swift_release {{.*}}
// CHECK: bitcast
// CHECK: llvm.lifetime.end
// CHECK: call {{.*}}llvm.lifetime.end{{.*}}, !dbg ![[CLOSURE_END:.*]]
diff --git a/test/DebugInfo/return.swift b/test/DebugInfo/return.swift
index 65c4584..2da1ff0 100644
--- a/test/DebugInfo/return.swift
+++ b/test/DebugInfo/return.swift
@@ -13,14 +13,14 @@
// CHECK: [[X:%.*]] = call {{.*}}%T6return1XC* @"$S6return1XC1iACs5Int64V_tcfC"(
// CHECK-SAME: i64 0, %swift.type* swiftself [[META]])
// CHECK: store %T6return1XC* [[X]], %T6return1XC** [[ALLOCA]]
- // CHECK: @swift_rt_swift_release to void (%T6return1XC*)*)(%T6return1XC* [[X]])
+ // CHECK: @swift_release to void (%T6return1XC*)*)(%T6return1XC* [[X]])
if true {
x.x += 1
} else {
x.x -= 1
}
// CHECK: [[X:%.*]] = load %T6return1XC*, %T6return1XC** [[ALLOCA]]
- // CHECK: @swift_rt_swift_release to void (%T6return1XC*)*)(%T6return1XC* [[X]])
+ // CHECK: @swift_release to void (%T6return1XC*)*)(%T6return1XC* [[X]])
// CHECK-SAME: , !dbg ![[RELEASE:.*]]
// The ret instruction should be in the same scope as the return expression.
diff --git a/test/Demangle/remangle.swift b/test/Demangle/remangle.swift
index c120765..616efd4 100644
--- a/test/Demangle/remangle.swift
+++ b/test/Demangle/remangle.swift
@@ -5,3 +5,7 @@
RUN: swift-demangle -test-remangle < %t.input > %t.output
RUN: diff %t.input %t.output
+
+// CHECK: Swift.(Mystruct in _7B40D7ED6632C2BEA2CA3BFFD57E3435)
+RUN: swift-demangle -remangle-objc-rt '$Ss8Mystruct33_7B40D7ED6632C2BEA2CA3BFFD57E3435LLV' | %FileCheck %s
+
diff --git a/test/IRGen/alloc_box.swift b/test/IRGen/alloc_box.swift
index d3ffa80..fd0d7b1 100644
--- a/test/IRGen/alloc_box.swift
+++ b/test/IRGen/alloc_box.swift
@@ -11,5 +11,5 @@
// CHECK-LABEL: @"$S9alloc_boxyycfU_"
// CHECK: <label>:8:
// CHECK-NOT: call void @swift_setDeallocating
-// CHECK: call void @swift_rt_swift_deallocUninitializedObject
+// CHECK: call void @swift_deallocUninitializedObject
diff --git a/test/IRGen/associated_type_witness.swift b/test/IRGen/associated_type_witness.swift
index 2470814..f304c69 100644
--- a/test/IRGen/associated_type_witness.swift
+++ b/test/IRGen/associated_type_witness.swift
@@ -142,7 +142,7 @@
// CHECK-NEXT: [[COUNT:%.*]] = getelementptr inbounds %swift.witness_table_slice, %swift.witness_table_slice* %conditional.tables, i32 0, i32 1
// CHECK-NEXT: store i64 %2, i64* [[COUNT]], align 8
// CHECK-NEXT: [[INSTANTIATION_ARGS:%.*]] = bitcast %swift.witness_table_slice* %conditional.tables to i8**
-// CHECK-NEXT: [[WTABLE:%.*]] = call i8** @swift_rt_swift_getGenericWitnessTable(%swift.generic_witness_table_cache* @"$S23associated_type_witness15GenericComputedVyxGAA22DerivedFromSimpleAssocAAWG", %swift.type* %0, i8** [[INSTANTIATION_ARGS]])
+// CHECK-NEXT: [[WTABLE:%.*]] = call i8** @swift_getGenericWitnessTable(%swift.generic_witness_table_cache* @"$S23associated_type_witness15GenericComputedVyxGAA22DerivedFromSimpleAssocAAWG", %swift.type* %0, i8** [[INSTANTIATION_ARGS]])
// CHECK-NEXT: ret i8** [[WTABLE]]
@@ -191,7 +191,7 @@
// CHECK-NEXT: [[COUNT:%.*]] = getelementptr inbounds %swift.witness_table_slice, %swift.witness_table_slice* %conditional.tables, i32 0, i32 1
// CHECK-NEXT: store i64 %2, i64* [[COUNT]], align 8
// CHECK-NEXT: [[INSTANTIATION_ARGS:%.*]] = bitcast %swift.witness_table_slice* %conditional.tables to i8**
-// CHECK-NEXT: [[WTABLE:%.*]] = call i8** @swift_rt_swift_getGenericWitnessTable(%swift.generic_witness_table_cache* @"$S23associated_type_witness15GenericComputedVyxGAA14HasSimpleAssocAAWG", %swift.type* %0, i8** [[INSTANTIATION_ARGS]])
+// CHECK-NEXT: [[WTABLE:%.*]] = call i8** @swift_getGenericWitnessTable(%swift.generic_witness_table_cache* @"$S23associated_type_witness15GenericComputedVyxGAA14HasSimpleAssocAAWG", %swift.type* %0, i8** [[INSTANTIATION_ARGS]])
// CHECK-NEXT: ret i8** [[WTABLE]]
diff --git a/test/IRGen/big_types_corner_cases.swift b/test/IRGen/big_types_corner_cases.swift
index 6510c35..7a2575a 100644
--- a/test/IRGen/big_types_corner_cases.swift
+++ b/test/IRGen/big_types_corner_cases.swift
@@ -120,7 +120,7 @@
// CHECK-LABEL: define{{( protected)?}} linkonce_odr hidden swiftcc { i8*, %swift.refcounted* } @"$S22big_types_corner_cases3FooC8myMethodyyyAA8MyStructV_SitcFTc"(%T22big_types_corner_cases3FooC*)
// CHECK: getelementptr inbounds %T22big_types_corner_cases3FooC, %T22big_types_corner_cases3FooC*
// CHECK: getelementptr inbounds void (i8*, %swift.refcounted*, %T22big_types_corner_cases3FooC*)*, void (i8*, %swift.refcounted*, %T22big_types_corner_cases3FooC*)**
-// CHECK: call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* getelementptr inbounds (%swift.full_boxmetadata, %swift.full_boxmetadata*
+// CHECK: call noalias %swift.refcounted* @swift_allocObject(%swift.type* getelementptr inbounds (%swift.full_boxmetadata, %swift.full_boxmetadata*
// CHECK: ret { i8*, %swift.refcounted* }
public enum LargeEnum {
diff --git a/test/IRGen/bitcast.sil b/test/IRGen/bitcast.sil
index 2b38ef3..a54ab3e 100644
--- a/test/IRGen/bitcast.sil
+++ b/test/IRGen/bitcast.sil
@@ -117,8 +117,8 @@
}
// CHECK-LABEL: define{{( protected)?}} swiftcc void @unchecked_ref_cast_addr
-// CHECK-i386: call i1 @swift_rt_swift_dynamicCast(%swift.opaque* %0, %swift.opaque* %{{.*}}, %swift.type* %T, %swift.type* %U, i32 7)
-// CHECK-x86_64: call i1 @swift_rt_swift_dynamicCast(%swift.opaque* %0, %swift.opaque* %{{.*}}, %swift.type* %T, %swift.type* %U, i64 7)
+// CHECK-i386: call i1 @swift_dynamicCast(%swift.opaque* %0, %swift.opaque* %{{.*}}, %swift.type* %T, %swift.type* %U, i32 7)
+// CHECK-x86_64: call i1 @swift_dynamicCast(%swift.opaque* %0, %swift.opaque* %{{.*}}, %swift.type* %T, %swift.type* %U, i64 7)
sil @unchecked_ref_cast_addr : $@convention(thin) <T, U> (@in T) -> @out U {
bb0(%0 : $*U, %1 : $*T):
%a = alloc_stack $T
diff --git a/test/IRGen/boxed_existential.sil b/test/IRGen/boxed_existential.sil
index 0bd30f9..3e9f0c9 100644
--- a/test/IRGen/boxed_existential.sil
+++ b/test/IRGen/boxed_existential.sil
@@ -8,12 +8,12 @@
sil @retain_release_boxed_existential : $@convention(thin) (@owned Error) -> () {
entry(%e : $Error):
// CHECK-objc: @swift_errorRetain
- // CHECK-native: @swift_rt_swift_retain
+ // CHECK-native: @swift_retain
strong_retain %e : $Error
%1 = function_ref @error_user : $@convention(thin) (@owned Error) -> ()
apply %1(%e) : $@convention(thin) (@owned Error) -> ()
// CHECK-objc: @swift_errorRelease
- // CHECK-native: @swift_rt_swift_release
+ // CHECK-native: @swift_release
strong_release %e : $Error
return undef : $()
}
@@ -105,7 +105,7 @@
%m = existential_metatype $@thick Error.Type, %b : $Error
// CHECK-objc: call void @swift_errorRelease(%swift.error* %0)
- // CHECK-native: call void bitcast (void (%swift.refcounted*)* @swift_rt_swift_release to void (%swift.error*)*)(%swift.error* %0)
+ // CHECK-native: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%swift.error*)*)(%swift.error* %0)
strong_release %b : $Error
// CHECK: [[RET:%.*]] = insertvalue { %swift.type*, i8** } undef, %swift.type* [[DYNAMIC_TYPE]], 0
diff --git a/test/IRGen/builtins.swift b/test/IRGen/builtins.swift
index 6f30f2a..3fcd691 100644
--- a/test/IRGen/builtins.swift
+++ b/test/IRGen/builtins.swift
@@ -152,7 +152,7 @@
// CHECK: define hidden {{.*}}%swift.refcounted* @"$S8builtins16load_object_test{{[_0-9a-zA-Z]*}}F"
func load_object_test(_ ptr: Builtin.RawPointer) -> Builtin.NativeObject {
// CHECK: [[T0:%.*]] = load [[REFCOUNT]]*, [[REFCOUNT]]**
- // CHECK: call [[REFCOUNT]]* @swift_rt_swift_retain([[REFCOUNT]]* returned [[T0]])
+ // CHECK: call [[REFCOUNT]]* @swift_retain([[REFCOUNT]]* returned [[T0]])
// CHECK: ret [[REFCOUNT]]* [[T0]]
return Builtin.load(ptr)
}
@@ -160,7 +160,7 @@
// CHECK: define hidden {{.*}}%swift.refcounted* @"$S8builtins20load_raw_object_test{{[_0-9a-zA-Z]*}}F"
func load_raw_object_test(_ ptr: Builtin.RawPointer) -> Builtin.NativeObject {
// CHECK: [[T0:%.*]] = load [[REFCOUNT]]*, [[REFCOUNT]]**
- // CHECK: call [[REFCOUNT]]* @swift_rt_swift_retain([[REFCOUNT]]* returned [[T0]])
+ // CHECK: call [[REFCOUNT]]* @swift_retain([[REFCOUNT]]* returned [[T0]])
// CHECK: ret [[REFCOUNT]]* [[T0]]
return Builtin.loadRaw(ptr)
}
@@ -643,7 +643,7 @@
// CHECK-LABEL: define hidden {{.*}}i1 @"$S8builtins8isUniqueyBi1_BozF"(%swift.refcounted** nocapture dereferenceable({{.*}})) {{.*}} {
// CHECK-NEXT: entry:
// CHECK-NEXT: load %swift.refcounted*, %swift.refcounted** %0
-// CHECK-NEXT: call i1 @swift_rt_swift_isUniquelyReferenced_nonNull_native(%swift.refcounted* %1)
+// CHECK-NEXT: call i1 @swift_isUniquelyReferenced_nonNull_native(%swift.refcounted* %1)
// CHECK-NEXT: ret i1 %2
func isUnique(_ ref: inout Builtin.NativeObject) -> Bool {
return Builtin.isUnique(&ref)
@@ -654,7 +654,7 @@
// CHECK-NEXT: entry:
// CHECK-NEXT: bitcast [[BUILTIN_NATIVE_OBJECT_TY]]* %0 to %swift.refcounted**
// CHECK-NEXT: load %swift.refcounted*, %swift.refcounted** %1
-// CHECK-NEXT: call i1 @swift_rt_swift_isUniquelyReferencedOrPinned_native(%swift.refcounted* %2)
+// CHECK-NEXT: call i1 @swift_isUniquelyReferencedOrPinned_native(%swift.refcounted* %2)
// CHECK-NEXT: ret i1 %3
func isUniqueOrPinned(_ ref: inout Builtin.NativeObject?) -> Bool {
return Builtin.isUniqueOrPinned(&ref)
@@ -664,7 +664,7 @@
// CHECK-LABEL: define hidden {{.*}}i1 @"$S8builtins16isUniqueOrPinnedyBi1_BozF"(%swift.refcounted** nocapture dereferenceable({{.*}})) {{.*}} {
// CHECK-NEXT: entry:
// CHECK-NEXT: load %swift.refcounted*, %swift.refcounted** %0
-// CHECK-NEXT: call i1 @swift_rt_swift_isUniquelyReferencedOrPinned_nonNull_native(%swift.refcounted* %1)
+// CHECK-NEXT: call i1 @swift_isUniquelyReferencedOrPinned_nonNull_native(%swift.refcounted* %1)
// CHECK-NEXT: ret i1 %2
func isUniqueOrPinned(_ ref: inout Builtin.NativeObject) -> Bool {
return Builtin.isUniqueOrPinned(&ref)
@@ -691,7 +691,7 @@
// CHECK-NEXT: entry:
// CHECK-NEXT: load [[UNKNOWN_OBJECT]]*, [[UNKNOWN_OBJECT]]** %0
// CHECK-objc-NEXT: call i1 @swift_isUniquelyReferencedNonObjC_nonNull([[UNKNOWN_OBJECT]]* %1)
-// CHECK-native-NEXT: call i1 @swift_rt_swift_isUniquelyReferenced_nonNull_native([[UNKNOWN_OBJECT]]* %1)
+// CHECK-native-NEXT: call i1 @swift_isUniquelyReferenced_nonNull_native([[UNKNOWN_OBJECT]]* %1)
// CHECK-NEXT: ret i1 %2
func isUnique(_ ref: inout Builtin.UnknownObject) -> Bool {
return Builtin.isUnique(&ref)
@@ -702,7 +702,7 @@
// CHECK-SAME: ([[UNKNOWN_OBJECT]]** nocapture dereferenceable({{.*}})) {{.*}} {
// CHECK-NEXT: entry:
// CHECK-NEXT: load [[UNKNOWN_OBJECT]]*, [[UNKNOWN_OBJECT]]** %0
-// CHECK-native-NEXT: call i1 @swift_rt_swift_isUniquelyReferencedOrPinned_nonNull_native([[UNKNOWN_OBJECT]]* %1)
+// CHECK-native-NEXT: call i1 @swift_isUniquelyReferencedOrPinned_nonNull_native([[UNKNOWN_OBJECT]]* %1)
// CHECK-objc-NEXT: call i1 @swift_isUniquelyReferencedOrPinnedNonObjC_nonNull([[UNKNOWN_OBJECT]]* %1)
// CHECK-NEXT: ret i1 %2
func isUniqueOrPinned(_ ref: inout Builtin.UnknownObject) -> Bool {
@@ -734,7 +734,7 @@
// CHECK-NEXT: entry:
// CHECK-NEXT: bitcast %swift.bridge** %0 to %swift.refcounted**
// CHECK-NEXT: load %swift.refcounted*, %swift.refcounted** %1
-// CHECK-NEXT: call i1 @swift_rt_swift_isUniquelyReferenced_nonNull_native(%swift.refcounted* %2)
+// CHECK-NEXT: call i1 @swift_isUniquelyReferenced_nonNull_native(%swift.refcounted* %2)
// CHECK-NEXT: ret i1 %3
func isUnique_native(_ ref: inout Builtin.BridgeObject) -> Bool {
return Builtin.isUnique_native(&ref)
@@ -745,7 +745,7 @@
// CHECK-NEXT: entry:
// CHECK-NEXT: bitcast %swift.bridge** %0 to %swift.refcounted**
// CHECK-NEXT: load %swift.refcounted*, %swift.refcounted** %1
-// CHECK-NEXT: call i1 @swift_rt_swift_isUniquelyReferencedOrPinned_nonNull_native(%swift.refcounted* %2)
+// CHECK-NEXT: call i1 @swift_isUniquelyReferencedOrPinned_nonNull_native(%swift.refcounted* %2)
// CHECK-NEXT: ret i1 %3
func isUniqueOrPinned_native(_ ref: inout Builtin.BridgeObject) -> Bool {
return Builtin.isUniqueOrPinned_native(&ref)
@@ -799,9 +799,9 @@
// CHECK-LABEL: define {{.*}} @{{.*}}unsafeGuaranteed_test
// CHECK: [[LOCAL:%.*]] = alloca %swift.refcounted*
-// CHECK: call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* returned %0)
+// CHECK: call %swift.refcounted* @swift_retain(%swift.refcounted* returned %0)
// CHECK: store %swift.refcounted* %0, %swift.refcounted** [[LOCAL]]
-// CHECK: call void @swift_rt_swift_release(%swift.refcounted* %0)
+// CHECK: call void @swift_release(%swift.refcounted* %0)
// CHECK: ret %swift.refcounted* %0
func unsafeGuaranteed_test(_ x: Builtin.NativeObject) -> Builtin.NativeObject {
var (g,t) = Builtin.unsafeGuaranteed(x)
diff --git a/test/IRGen/casts.sil b/test/IRGen/casts.sil
index 409acde..965a0e1 100644
--- a/test/IRGen/casts.sil
+++ b/test/IRGen/casts.sil
@@ -225,7 +225,7 @@
// CHECK: [[OBJ_PTR:%.*]] = bitcast %T5casts1AC* [[T0]] to i8*
// CHECK: [[METADATA:%.*]] = call %swift.type* @"$S5casts1ACMa"()
// CHECK: [[METADATA_PTR:%.*]] = bitcast %swift.type* [[METADATA]] to i8*
-// CHECK: [[RESULT_PTR:%.*]] = call i8* @swift_rt_swift_dynamicCastClass(i8* [[OBJ_PTR]], i8* [[METADATA_PTR]])
+// CHECK: [[RESULT_PTR:%.*]] = call i8* @swift_dynamicCastClass(i8* [[OBJ_PTR]], i8* [[METADATA_PTR]])
// CHECK: [[RESULT:%.*]] = bitcast i8* [[RESULT_PTR]] to %T5casts1AC*
// CHECK: [[COND:%.*]] = icmp ne %T5casts1AC* [[RESULT]], null
// CHECK: br i1 [[COND]]
diff --git a/test/IRGen/class.sil b/test/IRGen/class.sil
index 338a48e..34ae784 100644
--- a/test/IRGen/class.sil
+++ b/test/IRGen/class.sil
@@ -6,12 +6,12 @@
import Builtin
import Swift
-// CHECK: [[REF:%swift.refcounted]] = type
-// CHECK: [[TYPE:%swift.type]] = type
-// CHECK: [[OBJCCLASS:%objc_class]] = type
-// CHECK: [[OPAQUE:%swift.opaque]] = type opaque
-// CHECK: [[C_CLASS:%T5class1CC]] = type
-// CHECK: [[OBJCOBJ:%objc_object]] = type
+// CHECK-DAG: [[REF:%swift.refcounted]] = type
+// CHECK-DAG: [[TYPE:%swift.type]] = type
+// CHECK-DAG: [[OBJCCLASS:%objc_class]] = type
+// CHECK-DAG: [[OPAQUE:%swift.opaque]] = type opaque
+// CHECK-DAG: [[C_CLASS:%T5class1CC]] = type
+// CHECK-DAG: [[OBJCOBJ:%objc_object]] = type
class C {}
sil_vtable C {}
@@ -100,7 +100,7 @@
// CHECK: [[T1:%.*]] = bitcast i8* [[T0]] to i16*
// CHECK: [[ALIGN16:%.*]] = load i16, i16* [[T1]], align 4
// CHECK: [[ALIGN:%.*]] = zext i16 [[ALIGN16]] to i64
- // CHECK: [[RESULT:%[0-9]+]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* %0, i64 [[SIZE]], i64 [[ALIGN]])
+ // CHECK: [[RESULT:%[0-9]+]] = call noalias %swift.refcounted* @swift_allocObject(%swift.type* %0, i64 [[SIZE]], i64 [[ALIGN]])
%1 = alloc_ref_dynamic %0 : $@thick C.Type, $C
return %1 : $C
}
diff --git a/test/IRGen/class_resilience.sil b/test/IRGen/class_resilience.sil
index 3ed1b15..6f1fe46 100644
--- a/test/IRGen/class_resilience.sil
+++ b/test/IRGen/class_resilience.sil
@@ -31,7 +31,7 @@
// CHECK-NEXT: [[ALIGN_PTR:%.*]] = bitcast i8* [[ALIGN_ADDR]] to i16*
// CHECK-NEXT: [[ALIGN_2:%.*]] = load i16, i16* [[ALIGN_PTR]], align 4
// CHECK-NEXT: [[ALIGN:%.*]] = zext i16 [[ALIGN_2]] to i64
-// CHECK-NEXT: call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* [[META]], i64 [[SIZE]], i64 [[ALIGN]])
+// CHECK-NEXT: call noalias %swift.refcounted* @swift_allocObject(%swift.type* [[META]], i64 [[SIZE]], i64 [[ALIGN]])
sil @allocResilientOutsideParent : $@convention(thin) () -> () {
bb0:
diff --git a/test/IRGen/class_stack_alloc.sil b/test/IRGen/class_stack_alloc.sil
index 5d2cd21..8b05be7 100644
--- a/test/IRGen/class_stack_alloc.sil
+++ b/test/IRGen/class_stack_alloc.sil
@@ -34,7 +34,7 @@
// CHECK-NEXT: [[O:%[0-9]+]] = bitcast %[[C]]* %reference.raw to %swift.refcounted*
// CHECK-NEXT: %reference.new = call %swift.refcounted* @swift_initStackObject(%swift.type* [[M]], %swift.refcounted* [[O]])
// CHECK-NEXT: [[R:%[0-9]+]] = bitcast %swift.refcounted* %reference.new to %[[C]]*
-// CHECK-NEXT: call {{.*}} @swift_rt_swift_release {{.*}} [[R]])
+// CHECK-NEXT: call {{.*}} @swift_release {{.*}} [[R]])
// CHECK-NEXT: [[O2:%[0-9]+]] = bitcast %[[C]]* [[R]] to i8*
// CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[O2]])
// CHECK-NEXT: ret void
@@ -56,7 +56,7 @@
// CHECK: alloca {{.*}}TestStruct
// CHECK-NOT: alloca
// CHECK: call %swift.refcounted* @swift_initStackObject
-// CHECK: call noalias %swift.refcounted* @swift_rt_swift_allocObject
+// CHECK: call noalias %swift.refcounted* @swift_allocObject
// CHECK: ret void
sil @exceed_limit : $@convention(thin) () -> () {
bb0:
@@ -124,7 +124,7 @@
}
// CHECK-LABEL: define{{( protected)?}} swiftcc void @not_promoted_with_inlined_devirtualized_release
-// CHECK: [[O:%[0-9]+]] = call {{.*}} @swift_rt_swift_allocObject
+// CHECK: [[O:%[0-9]+]] = call {{.*}} @swift_allocObject
// CHECK-NEXT: [[BC:%[0-9]+]] = bitcast %swift.refcounted* [[O]] to
// CHECK-NEXT: call {{.*}} @swift_setDeallocating {{.*}}({{.*}} [[BC]])
// CHECK-NEXT: [[BC2:%[0-9]+]] = bitcast {{.*}} [[BC]] to %swift.refcounted*
diff --git a/test/IRGen/copy_value_destroy_value.sil b/test/IRGen/copy_value_destroy_value.sil
index ab36f89..bfdc2a9 100644
--- a/test/IRGen/copy_value_destroy_value.sil
+++ b/test/IRGen/copy_value_destroy_value.sil
@@ -32,10 +32,10 @@
// CHECK-NEXT: [[VAL1:%.*]] = load %swift.refcounted*, %swift.refcounted** [[GEP1]], align 8
// CHECK: [[GEP2:%.*]] = getelementptr inbounds %T019copy_value_destroy_B03FooV, %T019copy_value_destroy_B03FooV* %1, i32 0, i32 5
// CHECK-NEXT: [[VAL2:%.*]] = load %swift.refcounted*, %swift.refcounted** [[GEP2]], align 8
-// CHECK: call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* returned [[VAL1]])
-// CHECK: call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* returned [[VAL2]])
-// CHECK: call void @swift_rt_swift_release(%swift.refcounted* [[VAL1]])
-// CHECK: call void @swift_rt_swift_release(%swift.refcounted* [[VAL2]])
+// CHECK: call %swift.refcounted* @swift_retain(%swift.refcounted* returned [[VAL1]])
+// CHECK: call %swift.refcounted* @swift_retain(%swift.refcounted* returned [[VAL2]])
+// CHECK: call void @swift_release(%swift.refcounted* [[VAL1]])
+// CHECK: call void @swift_release(%swift.refcounted* [[VAL2]])
sil @non_trivial : $@convention(thin) (Foo) -> () {
bb0(%0 : $Foo):
%1 = copy_value %0 : $Foo
diff --git a/test/IRGen/dllimport.swift b/test/IRGen/dllimport.swift
index c303429..ee44b05 100644
--- a/test/IRGen/dllimport.swift
+++ b/test/IRGen/dllimport.swift
@@ -36,12 +36,12 @@
blackhole({ () -> () in })
}
-// CHECK-NO-OPT-DAG: @_swift_allocObject = external dllimport global %swift.refcounted* (%swift.type*, i32, i32)*
-// CHECK-NO-OPT-DAG: @_swift_deallocObject = external dllimport global void (%swift.refcounted*, i32, i32)*
-// CHECK-NO-OPT-DAG: @_swift_release = external dllimport global void (%swift.refcounted*)
-// CHECK-NO-OPT-DAG: @_swift_retain = external dllimport global %swift.refcounted* (%swift.refcounted*)
-// CHECK-NO-OPT-DAG: @_swift_slowAlloc = external dllimport global i8* (i32, i32)*
-// CHECK-NO-OPT-DAG: @_swift_slowDealloc = external dllimport global void (i8*, i32, i32)*
+// CHECK-NO-OPT-DAG: declare dllimport %swift.refcounted* @swift_allocObject(%swift.type*, i32, i32)
+// CHECK-NO-OPT-DAG: declare dllimport void @swift_deallocObject(%swift.refcounted*, i32, i32)
+// CHECK-NO-OPT-DAG: declare dllimport void @swift_release(%swift.refcounted*)
+// CHECK-NO-OPT-DAG: declare dllimport %swift.refcounted* @swift_retain(%swift.refcounted* returned)
+// CHECK-NO-OPT-DAG: declare dllimport i8* @swift_slowAlloc(i32, i32) #2
+// CHECK-NO-OPT-DAG: declare dllimport void @swift_slowDealloc(i8*, i32, i32) #2
// CHECK-NO-OPT-DAG: @"$S9dllexport1cCN" = external dllimport global %swift.type
// CHECK-NO-OPT-DAG: @"$S9dllexport1pMp" = external dllimport global %swift.protocol
// CHECK-NO-OPT-DAG: @"$SytN" = external dllimport global %swift.full_type
@@ -50,21 +50,14 @@
// CHECK-NO-OPT-DAG: declare dllimport swiftcc %swift.refcounted* @"$S9dllexport1cCfd"(%T9dllexport1cC* swiftself)
// CHECK-NO-OPT-DAG: declare dllimport %swift.type* @"$S9dllexport1cCMa"()
// CHECK-NO-OPT-DAG: declare dllimport void @swift_deallocClassInstance(%swift.refcounted*, i32, i32)
-// CHECK-NO-OPT-DAG: define linkonce_odr hidden i8* @swift_rt_swift_slowAlloc(i32, i32)
-// CHECK-NO-OPT-DAG: define linkonce_odr hidden void @swift_rt_swift_release(%swift.refcounted*)
-// CHECK-NO-OPT-DAG: define linkonce_odr hidden %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* returned)
-// CHECK-NO-OPT-DAG: define linkonce_odr hidden void @swift_rt_swift_slowDealloc(i8*, i32, i32)
-// CHECK-OPT-DAG: @_swift_retain = external dllimport local_unnamed_addr global %swift.refcounted* (%swift.refcounted*)
+// CHECK-OPT-DAG: declare dllimport %swift.refcounted* @swift_retain(%swift.refcounted* returned) local_unnamed_addr
// CHECK-OPT-DAG: @"$SBoWV" = external dllimport global i8*
// CHECK-OPT-DAG: @"$S9dllexport1cCN" = external dllimport global %swift.type
// CHECK-OPT-DAG: @"$S9dllexport1pMp" = external dllimport global %swift.protocol
-// CHECK-OPT-DAG: @_swift_slowAlloc = external dllimport local_unnamed_addr global i8* (i32, i32)*
-// CHECK-OPT-DAG: @_swift_slowDealloc = external dllimport local_unnamed_addr global void (i8*, i32, i32)*
+// CHECK-OPT-DAG: declare dllimport i8* @swift_slowAlloc(i32, i32) local_unnamed_addr
+// CHECK-OPT-DAG: declare dllimport void @swift_slowDealloc(i8*, i32, i32) local_unnamed_addr
// CHECK-OPT-DAG: declare dllimport swiftcc i8* @"$S9dllexport2ciAA1cCvau"()
// CHECK-OPT-DAG: declare dllimport %swift.type* @"$S9dllexport1cCMa"()
// CHECK-OPT-DAG: declare dllimport void @swift_deallocClassInstance(%swift.refcounted*, i32, i32)
// CHECK-OPT-DAG: declare dllimport swiftcc %swift.refcounted* @"$S9dllexport1cCfd"(%T9dllexport1cC* swiftself)
-// CHECK-OPT-DAG: define linkonce_odr hidden i8* @swift_rt_swift_slowAlloc(i32, i32)
-// CHECK-OPT-DAG: define linkonce_odr hidden void @swift_rt_swift_slowDealloc(i8*, i32, i32)
-
diff --git a/test/IRGen/dynamic_cast.sil b/test/IRGen/dynamic_cast.sil
index b960715..dc35f9b 100644
--- a/test/IRGen/dynamic_cast.sil
+++ b/test/IRGen/dynamic_cast.sil
@@ -26,7 +26,7 @@
// CHECK: [[T1:%.*]] = bitcast [[S]]* [[T0]] to [[OPAQUE:%swift.opaque]]*
// CHECK: [[T2:%.*]] = bitcast [[P:%.*]]* {{%.*}} to [[OPAQUE]]*
// CHECK: [[T3:%.*]] = call [[TYPE:%.*]]* @"$S12dynamic_cast1P_pMa"()
- // CHECK: call i1 @swift_rt_swift_dynamicCast([[OPAQUE]]* [[T1]], [[OPAQUE]]* [[T2]], [[TYPE]]* [[T3]], [[TYPE]]* {{.*}}, [[LLVM_PTRSIZE_INT]] 7)
+ // CHECK: call i1 @swift_dynamicCast([[OPAQUE]]* [[T1]], [[OPAQUE]]* [[T2]], [[TYPE]]* [[T3]], [[TYPE]]* {{.*}}, [[LLVM_PTRSIZE_INT]] 7)
%1 = alloc_stack $S
unconditional_checked_cast_addr P in %0 : $*P to S in %1 : $*S
destroy_addr %1 : $*S
@@ -36,7 +36,7 @@
}
// CHECK-LABEL: define linkonce_odr hidden %swift.type* @"$S12dynamic_cast1P_pMa"()
-// CHECK: call %swift.type* @swift_rt_swift_getExistentialTypeMetadata(
+// CHECK: call %swift.type* @swift_getExistentialTypeMetadata(
// CHECK-LABEL: define{{( protected)?}} swiftcc void @testUnconditional1(
sil @testUnconditional1 : $@convention(thin) (@in P) -> () {
@@ -45,7 +45,7 @@
// CHECK: [[T1:%.*]] = bitcast [[S]]* [[T0]] to [[OPAQUE:%swift.opaque]]*
// CHECK: [[T2:%.*]] = bitcast [[P:%.*]]* {{%.*}} to [[OPAQUE]]*
// CHECK: [[T3:%.*]] = call [[TYPE:%.*]]* @"$S12dynamic_cast1P_pMa"()
- // CHECK: call i1 @swift_rt_swift_dynamicCast([[OPAQUE]]* [[T1]], [[OPAQUE]]* [[T2]], [[TYPE]]* [[T3]], [[TYPE]]* {{.*}}, [[LLVM_PTRSIZE_INT]] 7)
+ // CHECK: call i1 @swift_dynamicCast([[OPAQUE]]* [[T1]], [[OPAQUE]]* [[T2]], [[TYPE]]* [[T3]], [[TYPE]]* {{.*}}, [[LLVM_PTRSIZE_INT]] 7)
%1 = alloc_stack $S
unconditional_checked_cast_addr P in %0 : $*P to S in %1 : $*S
destroy_addr %1 : $*S
@@ -61,7 +61,7 @@
// CHECK: [[T1:%.*]] = bitcast [[S]]* [[T0]] to [[OPAQUE:%swift.opaque]]*
// CHECK: [[T2:%.*]] = bitcast [[P:%.*]]* {{%.*}} to [[OPAQUE]]*
// CHECK: [[T3:%.*]] = call [[TYPE:%.*]]* @"$S12dynamic_cast1P_pMa"()
- // CHECK: [[T4:%.*]] = call i1 @swift_rt_swift_dynamicCast([[OPAQUE]]* [[T1]], [[OPAQUE]]* [[T2]], [[TYPE]]* [[T3]], [[TYPE]]* {{.*}}, [[LLVM_PTRSIZE_INT]] 6)
+ // CHECK: [[T4:%.*]] = call i1 @swift_dynamicCast([[OPAQUE]]* [[T1]], [[OPAQUE]]* [[T2]], [[TYPE]]* [[T3]], [[TYPE]]* {{.*}}, [[LLVM_PTRSIZE_INT]] 6)
// CHECK: br i1 [[T4]],
%1 = alloc_stack $S
checked_cast_addr_br take_always P in %0 : $*P to S in %1 : $*S, bb1, bb2
@@ -81,7 +81,7 @@
// CHECK: [[T1:%.*]] = bitcast [[S]]* [[T0]] to [[OPAQUE:%swift.opaque]]*
// CHECK: [[T2:%.*]] = bitcast [[P:%.*]]* {{%.*}} to [[OPAQUE]]*
// CHECK: [[T3:%.*]] = call [[TYPE:%.*]]* @"$S12dynamic_cast1P_pMa"()
- // CHECK: [[T4:%.*]] = call i1 @swift_rt_swift_dynamicCast([[OPAQUE]]* [[T1]], [[OPAQUE]]* [[T2]], [[TYPE]]* [[T3]], [[TYPE]]* {{.*}}, [[LLVM_PTRSIZE_INT]] 2)
+ // CHECK: [[T4:%.*]] = call i1 @swift_dynamicCast([[OPAQUE]]* [[T1]], [[OPAQUE]]* [[T2]], [[TYPE]]* [[T3]], [[TYPE]]* {{.*}}, [[LLVM_PTRSIZE_INT]] 2)
// CHECK: br i1 [[T4]],
%1 = alloc_stack $S
checked_cast_addr_br take_on_success P in %0 : $*P to S in %1 : $*S, bb1, bb2
@@ -101,7 +101,7 @@
// CHECK: [[T1:%.*]] = bitcast [[S]]* [[T0]] to [[OPAQUE:%swift.opaque]]*
// CHECK: [[T2:%.*]] = bitcast [[P:%.*]]* {{%.*}} to [[OPAQUE]]*
// CHECK: [[T3:%.*]] = call [[TYPE:%.*]]* @"$S12dynamic_cast1P_pMa"()
- // CHECK: [[T4:%.*]] = call i1 @swift_rt_swift_dynamicCast([[OPAQUE]]* [[T1]], [[OPAQUE]]* [[T2]], [[TYPE]]* [[T3]], [[TYPE]]* {{.*}}, [[LLVM_PTRSIZE_INT]] 0)
+ // CHECK: [[T4:%.*]] = call i1 @swift_dynamicCast([[OPAQUE]]* [[T1]], [[OPAQUE]]* [[T2]], [[TYPE]]* [[T3]], [[TYPE]]* {{.*}}, [[LLVM_PTRSIZE_INT]] 0)
// CHECK: br i1 [[T4]],
%1 = alloc_stack $S
checked_cast_addr_br copy_on_success P in %0 : $*P to S in %1 : $*S, bb1, bb2
diff --git a/test/IRGen/dynamic_init.sil b/test/IRGen/dynamic_init.sil
index f30eb43..e272afb 100644
--- a/test/IRGen/dynamic_init.sil
+++ b/test/IRGen/dynamic_init.sil
@@ -25,7 +25,7 @@
%2 = class_method %0 : $@thick C.Type, #C.init!allocator.1 : (C.Type) -> () -> C, $@convention(method) (@thick C.Type) -> @owned C
// CHECK: [[RESULT:%[0-9]+]] = call swiftcc %T12dynamic_init1CC* [[CTOR]](%swift.type* swiftself %0)
%3 = apply %2(%0) : $@convention(method) (@thick C.Type) -> @owned C
- // CHECK: call void bitcast (void (%swift.refcounted*)* @swift_rt_swift_release to void (%T12dynamic_init1CC*)*)(%T12dynamic_init1CC* [[RESULT]])
+ // CHECK: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T12dynamic_init1CC*)*)(%T12dynamic_init1CC* [[RESULT]])
strong_release %3 : $C
// CHECK: ret void
%5 = tuple ()
diff --git a/test/IRGen/enum_dynamic_multi_payload.sil b/test/IRGen/enum_dynamic_multi_payload.sil
index 7833685..81c4b78 100644
--- a/test/IRGen/enum_dynamic_multi_payload.sil
+++ b/test/IRGen/enum_dynamic_multi_payload.sil
@@ -381,7 +381,7 @@
// CHECK: call void %destroy(%swift.opaque* noalias {{%.*}}, %swift.type* %T)
// CHECK: br label %[[NOOP]]
// CHECK: <label>:[[RIGHT]]
- // CHECK: call void {{.*}} @swift_rt_swift_release
+ // CHECK: call void {{.*}} @swift_release
// CHECK: <label>:[[NOOP]]
destroy_addr %a : $*EitherOr<T, C>
@@ -408,7 +408,7 @@
// CHECK: call %swift.opaque* %initializeWithCopy(%swift.opaque* noalias {{%.*}}, %swift.type* %T)
// CHECK: br label %[[DONE:[0-9]+]]
// CHECK: <label>:[[RIGHT]]
- // CHECK: call %swift.refcounted* @swift_rt_swift_retain
+ // CHECK: call %swift.refcounted* @swift_retain
// CHECK: br label %[[DONE:[0-9]+]]
// CHECK: <label>:[[TRIVIAL]]
// CHECK: call void @llvm.memcpy
diff --git a/test/IRGen/enum_resilience.swift b/test/IRGen/enum_resilience.swift
index 7cef5df..621dfb7 100644
--- a/test/IRGen/enum_resilience.swift
+++ b/test/IRGen/enum_resilience.swift
@@ -204,7 +204,7 @@
// CHECK-LABEL: define{{( protected)?}} swiftcc void @"$S15enum_resilience25resilientEnumPartialApplyyySi0c1_A06MediumOcF"(i8*, %swift.refcounted*)
public func resilientEnumPartialApply(_ f: (Medium) -> Int) {
-// CHECK: [[CONTEXT:%.*]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject
+// CHECK: [[CONTEXT:%.*]] = call noalias %swift.refcounted* @swift_allocObject
// CHECK: call swiftcc void @"$S15enum_resilience13reabstractionyyx010resilient_A06MediumOclF"(i8* bitcast (void (%TSi*, %swift.opaque*, %swift.refcounted*)* @"$S14resilient_enum6MediumOSiIgid_ACSiIgir_TRTA" to i8*), %swift.refcounted* [[CONTEXT:%.*]], %swift.type* @"$SSiN")
reabstraction(f)
@@ -275,4 +275,4 @@
}
// CHECK-LABEL: define{{( protected)?}} internal %T15enum_resilience19ProtGenEnumWithSize33_59077B69D65A4A3BEE0C93708067D5F0LLO* @"$S15enum_resilienceytWh2_"(%T15enum_resilience19ProtGenEnumWithSize
-// CHECK: ret %T15enum_resilience19ProtGenEnumWithSize33_59077B69D65A4A3BEE0C93708067D5F0LLO* %0
\ No newline at end of file
+// CHECK: ret %T15enum_resilience19ProtGenEnumWithSize33_59077B69D65A4A3BEE0C93708067D5F0LLO* %0
diff --git a/test/IRGen/enum_value_semantics.sil b/test/IRGen/enum_value_semantics.sil
index 8d32502..ff2167e 100644
--- a/test/IRGen/enum_value_semantics.sil
+++ b/test/IRGen/enum_value_semantics.sil
@@ -282,7 +282,7 @@
// CHECK: ; <label>:[[RELEASE_PAYLOAD]]
// CHECK-NEXT: [[DATA_ADDR:%.*]] = bitcast %T20enum_value_semantics23SinglePayloadNontrivialO* [[ADDR]] to %swift.refcounted**
// CHECK-NEXT: [[DATA:%.*]] = load %swift.refcounted*, %swift.refcounted** [[DATA_ADDR]], align 8
-// CHECK-NEXT: call void @swift_rt_swift_release(%swift.refcounted* [[DATA]])
+// CHECK-NEXT: call void @swift_release(%swift.refcounted* [[DATA]])
// CHECK-NEXT: br label %[[DONE]]
// CHECK: ; <label>:[[DONE]]
diff --git a/test/IRGen/enum_value_semantics_special_cases.sil b/test/IRGen/enum_value_semantics_special_cases.sil
index 70c211d..358982c 100644
--- a/test/IRGen/enum_value_semantics_special_cases.sil
+++ b/test/IRGen/enum_value_semantics_special_cases.sil
@@ -16,7 +16,7 @@
// CHECK: %0 = bitcast %swift.opaque* %object to %T34enum_value_semantics_special_cases18NullableRefcountedO*
// CHECK: %1 = bitcast %T34enum_value_semantics_special_cases18NullableRefcountedO* %0 to %swift.refcounted**
// CHECK: %2 = load %swift.refcounted*, %swift.refcounted** %1, align 8
-// CHECK: call void @swift_rt_swift_release(%swift.refcounted* %2) {{#[0-9]+}}
+// CHECK: call void @swift_release(%swift.refcounted* %2)
// CHECK: ret void
// CHECK: }
@@ -27,7 +27,7 @@
// CHECK: %2 = bitcast %T34enum_value_semantics_special_cases18NullableRefcountedO* %0 to %swift.refcounted**
// CHECK: %3 = bitcast %T34enum_value_semantics_special_cases18NullableRefcountedO* %1 to %swift.refcounted**
// CHECK: %4 = load %swift.refcounted*, %swift.refcounted** %3, align 8
-// CHECK: %5 = call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* returned %4) #2
+// CHECK: %5 = call %swift.refcounted* @swift_retain(%swift.refcounted* returned %4)
// CHECK: store %swift.refcounted* %4, %swift.refcounted** %2, align 8
// CHECK: %6 = bitcast %T34enum_value_semantics_special_cases18NullableRefcountedO* %0 to %swift.opaque*
// CHECK: ret %swift.opaque* %6
@@ -41,9 +41,9 @@
// CHECK: %3 = bitcast %T34enum_value_semantics_special_cases18NullableRefcountedO* %1 to %swift.refcounted**
// CHECK: %4 = load %swift.refcounted*, %swift.refcounted** %2, align 8
// CHECK: %5 = load %swift.refcounted*, %swift.refcounted** %3, align 8
-// CHECK: %6 = call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* returned %5) #2
+// CHECK: %6 = call %swift.refcounted* @swift_retain(%swift.refcounted* returned %5)
// CHECK: store %swift.refcounted* %5, %swift.refcounted** %2, align 8
-// CHECK: call void @swift_rt_swift_release(%swift.refcounted* %4) #2
+// CHECK: call void @swift_release(%swift.refcounted* %4)
// CHECK: %7 = bitcast %T34enum_value_semantics_special_cases18NullableRefcountedO* %0 to %swift.opaque*
// CHECK: ret %swift.opaque* %7
// CHECK: }
@@ -57,7 +57,7 @@
// CHECK: %4 = load %swift.refcounted*, %swift.refcounted** %2, align 8
// CHECK: %5 = load %swift.refcounted*, %swift.refcounted** %3, align 8
// CHECK: store %swift.refcounted* %5, %swift.refcounted** %2, align 8
-// CHECK: call void @swift_rt_swift_release(%swift.refcounted* %4) #2
+// CHECK: call void @swift_release(%swift.refcounted* %4)
// CHECK: %6 = bitcast %T34enum_value_semantics_special_cases18NullableRefcountedO* %0 to %swift.opaque*
// CHECK: ret %swift.opaque* %6
// CHECK: }
@@ -74,7 +74,7 @@
// CHECK: %0 = bitcast %swift.opaque* %object to %T34enum_value_semantics_special_cases23NullableBlockRefcountedO*
// CHECK: %1 = bitcast %T34enum_value_semantics_special_cases23NullableBlockRefcountedO* %0 to %objc_block**
// CHECK: %2 = load %objc_block*, %objc_block** %1, align 8
-// CHECK: call void @_Block_release(%objc_block* %2) {{#[0-9]+}}
+// CHECK: call void @_Block_release(%objc_block* %2)
// CHECK: ret void
// CHECK: }
@@ -101,7 +101,7 @@
// CHECK: %5 = load %objc_block*, %objc_block** %3, align 8
// CHECK: %6 = call %objc_block* @_Block_copy(%objc_block* %5)
// CHECK: store %objc_block* %5, %objc_block** %2, align 8
-// CHECK: call void @_Block_release(%objc_block* %4) #2
+// CHECK: call void @_Block_release(%objc_block* %4)
// CHECK: %7 = bitcast %T34enum_value_semantics_special_cases23NullableBlockRefcountedO* %0 to %swift.opaque*
// CHECK: ret %swift.opaque* %7
// CHECK: }
@@ -115,7 +115,7 @@
// CHECK: %4 = load %objc_block*, %objc_block** %2, align 8
// CHECK: %5 = load %objc_block*, %objc_block** %3, align 8
// CHECK: store %objc_block* %5, %objc_block** %2, align 8
-// CHECK: call void @_Block_release(%objc_block* %4) #2
+// CHECK: call void @_Block_release(%objc_block* %4)
// CHECK: %6 = bitcast %T34enum_value_semantics_special_cases23NullableBlockRefcountedO* %0 to %swift.opaque*
// CHECK: ret %swift.opaque* %6
// CHECK: }
@@ -139,7 +139,7 @@
// CHECK: ; <label>:3: ; preds = %entry
// CHECK: %4 = bitcast %T34enum_value_semantics_special_cases23MultipleEmptyRefcountedO* %0 to %swift.refcounted**
// CHECK: %toDestroy = load %swift.refcounted*, %swift.refcounted** %4, align 8
-// CHECK: call void @swift_rt_swift_release(%swift.refcounted* %toDestroy) {{#[0-9]+}}
+// CHECK: call void @swift_release(%swift.refcounted* %toDestroy)
// CHECK: br label %5
// CHECK: ; <label>:5: ; preds = %3, %entry, %entry
// CHECK: ret void
@@ -172,7 +172,7 @@
// -- 0x3fffffffffffffff
// CHECK: %3 = and i64 %2, 4611686018427387903
// CHECK: %4 = inttoptr i64 %3 to %swift.refcounted*
-// CHECK: call void @swift_rt_swift_release(%swift.refcounted* %4) {{#[0-9]+}}
+// CHECK: call void @swift_release(%swift.refcounted* %4)
// CHECK: ret void
// CHECK: }
@@ -180,7 +180,7 @@
// -- 0x3fffffffffffffff
// CHECK: %4 = and i64 %3, 4611686018427387903
// CHECK: %5 = inttoptr i64 %4 to %swift.refcounted*
-// CHECK: call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* returned %5)
+// CHECK: call %swift.refcounted* @swift_retain(%swift.refcounted* returned %5)
// CHECK: %6 = bitcast %T34enum_value_semantics_special_cases13AllRefcountedO* %0 to i64*
// -- NB: The original loaded value is stored, not the masked one.
// CHECK: store i64 %3, i64* %6, align 8
diff --git a/test/IRGen/errors.sil b/test/IRGen/errors.sil
index aa47378..5eb9404 100644
--- a/test/IRGen/errors.sil
+++ b/test/IRGen/errors.sil
@@ -76,7 +76,7 @@
// CHECK-objc: [[T0:%.*]] = phi %objc_object* [ [[RESULT]],
// CHECK-objc-NEXT: call void @swift_unknownRelease(%objc_object* [[T0]])
// CHECK-native: [[T0:%.*]] = phi %swift.refcounted* [ [[RESULT]],
-// CHECK-native-NEXT: call void @swift_rt_swift_release(%swift.refcounted* [[T0]])
+// CHECK-native-NEXT: call void @swift_release(%swift.refcounted* [[T0]])
// CHECK-NEXT: br label [[CONT:%[0-9]+]]
bb1(%2 : $AnyObject):
strong_release %2 : $AnyObject
@@ -85,7 +85,7 @@
// CHECK: [[T0:%.*]] = phi %swift.error* [ [[ERR]],
// CHECK-NEXT: store %swift.error* null, %swift.error** [[ERRORSLOT]], align
// CHECK-objc-NEXT: call void @swift_errorRelease(%swift.error* [[T0]])
-// CHECK-native-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_rt_swift_release to void (%swift.error*)*)(%swift.error* [[T0]])
+// CHECK-native-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%swift.error*)*)(%swift.error* [[T0]])
// CHECK-NEXT: br label [[CONT]]
bb2(%3 : $Error):
release_value %3 : $Error
diff --git a/test/IRGen/existentials.sil b/test/IRGen/existentials.sil
index 694b286..5c182e7 100644
--- a/test/IRGen/existentials.sil
+++ b/test/IRGen/existentials.sil
@@ -12,15 +12,15 @@
sil @class_existential_unowned : $@convention(thin) (@owned CP) -> @owned CP {
entry(%s : $CP):
%u = ref_to_unowned %s : $CP to $@sil_unowned CP
- // CHECK: call %swift.refcounted* @swift_rt_swift_unownedRetain(%swift.refcounted* returned %0)
+ // CHECK: call %swift.refcounted* @swift_unownedRetain(%swift.refcounted* returned %0)
unowned_retain %u : $@sil_unowned CP
- // CHECK: call void @swift_rt_swift_unownedRelease(%swift.refcounted* %0)
+ // CHECK: call void @swift_unownedRelease(%swift.refcounted* %0)
unowned_release %u : $@sil_unowned CP
- // CHECK: call %swift.refcounted* @swift_rt_swift_unownedRetainStrong(%swift.refcounted* returned %0)
+ // CHECK: call %swift.refcounted* @swift_unownedRetainStrong(%swift.refcounted* returned %0)
strong_retain_unowned %u : $@sil_unowned CP
%t = unowned_to_ref %u : $@sil_unowned CP to $CP
- // CHECK: call void @swift_rt_swift_release(%swift.refcounted* %0)
+ // CHECK: call void @swift_release(%swift.refcounted* %0)
strong_release %t : $CP
%v = ref_to_unmanaged %s : $CP to $@sil_unmanaged CP
diff --git a/test/IRGen/existentials_opaque_boxed.sil b/test/IRGen/existentials_opaque_boxed.sil
index ac11959..3ba158b 100644
--- a/test/IRGen/existentials_opaque_boxed.sil
+++ b/test/IRGen/existentials_opaque_boxed.sil
@@ -80,7 +80,7 @@
// CHECK: [[CONTAINER:%.*]] = alloca %T25existentials_opaque_boxed11ExistentialP
// CHECK: [[INLINEBUFFER:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, %T25existentials_opaque_boxed11ExistentialP* [[CONTAINER]], i32 0, i32 0
// CHECK: [[INLINEBUFFER:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, %T25existentials_opaque_boxed11ExistentialP* [[CONTAINER]], i32 0, i32 0
-// CHECK: [[BOX:%.*]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* getelementptr inbounds (%swift.full_boxmetadata, %swift.full_boxmetadata* @metadata, i32 0, i32 2), {{(i64 48|i32 40)}}, {{(i64|i32)}} 7)
+// CHECK: [[BOX:%.*]] = call noalias %swift.refcounted* @swift_allocObject(%swift.type* getelementptr inbounds (%swift.full_boxmetadata, %swift.full_boxmetadata* @metadata, i32 0, i32 2), {{(i64 48|i32 40)}}, {{(i64|i32)}} 7)
// CHECK: [[BOX_ADDR:%.*]] = bitcast %swift.refcounted* [[BOX]] to <{ %swift.refcounted{{(, \[4 x i8\])?}}, [32 x i8] }>*
// CHECK: [[VALUE_ADDR:%.*]] = getelementptr inbounds <{ %swift.refcounted{{(, \[4 x i8\])?}}, [32 x i8] }>, <{ %swift.refcounted{{(, \[4 x i8\])?}}, [32 x i8] }>* [[BOX_ADDR]], i32 0, i32 {{(1|2)}}
// CHECK: [[INIT_EXIST_ADDR:%.*]] = bitcast [32 x i8]* [[VALUE_ADDR]] to %T25existentials_opaque_boxed14NotInlineFixedV*
@@ -142,7 +142,7 @@
// CHECK: [[HEAPSIZE:%.*]] = add {{(i64|i32)}} [[ALIGNEDSTART]], [[SIZE]]
// CHECK: [[ALIGNMASK_ATLEASTPOINTER:%.*]] = or {{(i64|i32)}} [[ALIGNMASK]], {{(7|3)}}
// CHECK: [[PTR:%.*]] = bitcast %swift.refcounted* [[REFERENCE]] to i8*
-// CHECK: call void @swift_rt_swift_slowDealloc(i8* [[PTR]], {{(i64|i32)}} [[HEAPSIZE]], {{(i64|i32)}} [[ALIGNMASK_ATLEASTPOINTER]])
+// CHECK: call void @swift_slowDealloc(i8* [[PTR]], {{(i64|i32)}} [[HEAPSIZE]], {{(i64|i32)}} [[ALIGNMASK_ATLEASTPOINTER]])
// CHECK: ret void
// CHECK-LABEL: define {{.*}} @test_open_existential_addr_immutable(%T25existentials_opaque_boxed11ExistentialP*
@@ -265,7 +265,7 @@
// CHECK: outline:
// CHECK: [[REFERENCE_ADDR:%.*]] = bitcast [{{(24|12)}} x i8]* [[BUFFER_ADDR]] to %swift.refcounted**
// CHECK: [[REFERENCE:%.*]] = load %swift.refcounted*, %swift.refcounted** [[REFERENCE_ADDR]]
-// CHECK: call void @swift_rt_swift_release(%swift.refcounted* [[REFERENCE]])
+// CHECK: call void @swift_release(%swift.refcounted* [[REFERENCE]])
// CHECK: ret void
// CHECK-LABEL: define{{( protected)?}} swiftcc void @test_assignWithCopy_existential_addr(%T25existentials_opaque_boxed11ExistentialP*
@@ -325,8 +325,8 @@
// CHECK: [[SRC_REFADDR:%.*]] = bitcast [{{(24|12)}} x i8]* [[SRC_BUFFERADDR]] to %swift.refcounted**
// CHECK: [[DEST_REF:%.*]] = load %swift.refcounted*, %swift.refcounted** [[DEST_REFADDR]]
// CHECK: [[SRC_REF:%.*]] = load %swift.refcounted*, %swift.refcounted** [[SRC_REFADDR]]
-// CHECK: call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* returned [[SRC_REF]])
-// CHECK: call void @swift_rt_swift_release(%swift.refcounted* [[DEST_REF]])
+// CHECK: call %swift.refcounted* @swift_retain(%swift.refcounted* returned [[SRC_REF]])
+// CHECK: call void @swift_release(%swift.refcounted* [[DEST_REF]])
// CHECK: store %swift.refcounted* [[SRC_REF]], %swift.refcounted** [[DEST_REFADDR]]
// CHECK: br label %done
@@ -382,7 +382,7 @@
// CHECK: [[DEST_REFADDR:%.*]] = bitcast [{{(24|12)}} x i8]* [[DEST_BUFFERADDR]] to %swift.refcounted**
// CHECK: [[SRC_REFADDR:%.*]] = bitcast [{{(24|12)}} x i8]* [[SRC_BUFFERADDR]] to %swift.refcounted**
// CHECK: [[SRC_REF:%.*]] = load %swift.refcounted*, %swift.refcounted** [[SRC_REFADDR]]
-// CHECK: call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* returned [[SRC_REF]])
+// CHECK: call %swift.refcounted* @swift_retain(%swift.refcounted* returned [[SRC_REF]])
// CHECK: store %swift.refcounted* [[SRC_REF]], %swift.refcounted** [[DEST_REFADDR]]
// CHECK: br label %dest-inline-cont
//
@@ -418,12 +418,12 @@
// CHECK: [[DEST_REFADDR:%.*]] = bitcast [{{(24|12)}} x i8]* [[DEST_BUFFERADDR]] to %swift.refcounted**
// CHECK: [[SRC_REFADDR:%.*]] = bitcast [{{(24|12)}} x i8]* [[SRC_BUFFERADDR]] to %swift.refcounted**
// CHECK: [[SRC_REF:%.*]] = load %swift.refcounted*, %swift.refcounted** [[SRC_REFADDR]]
-// CHECK: call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* returned [[SRC_REF]])
+// CHECK: call %swift.refcounted* @swift_retain(%swift.refcounted* returned [[SRC_REF]])
// CHECK: store %swift.refcounted* [[SRC_REF]], %swift.refcounted** [[DEST_REFADDR]]
// CHECK: br label %dest-outline-cont
//
// CHECK: dest-outline-cont:
-// CHECK: call void @swift_rt_swift_release(%swift.refcounted* [[DEST_REF]])
+// CHECK: call void @swift_release(%swift.refcounted* [[DEST_REF]])
// CHECK: br label %done
//
// CHECK: done:
@@ -518,7 +518,7 @@
// CHECK: [[CONTAINER:%.*]] = alloca %T25existentials_opaque_boxed11ExistentialP
// CHECK: [[INLINEBUFFER:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, %T25existentials_opaque_boxed11ExistentialP* [[CONTAINER]], i32 0, i32 0
// CHECK: [[INLINEBUFFER:%.*]] = getelementptr inbounds %T25existentials_opaque_boxed11ExistentialP, %T25existentials_opaque_boxed11ExistentialP* [[CONTAINER]], i32 0, i32 0
-// CHECK: [[BOX:%.*]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* getelementptr inbounds (%swift.full_boxmetadata, %swift.full_boxmetadata* @metadata.3, i32 0, i32 2), {{(i64|i32)}} 64, {{(i64|i32)}} 31)
+// CHECK: [[BOX:%.*]] = call noalias %swift.refcounted* @swift_allocObject(%swift.type* getelementptr inbounds (%swift.full_boxmetadata, %swift.full_boxmetadata* @metadata.3, i32 0, i32 2), {{(i64|i32)}} 64, {{(i64|i32)}} 31)
// CHECK: [[BOX_ADDR:%.*]] = bitcast %swift.refcounted* [[BOX]] to <{ %swift.refcounted, [{{(16|24)}} x i8], [32 x i8] }>*
// CHECK: [[VALUE_ADDR:%.*]] = getelementptr inbounds <{ %swift.refcounted, [{{(16|24)}} x i8], [32 x i8] }>, <{ %swift.refcounted, [{{(16|24)}} x i8], [32 x i8] }>* [[BOX_ADDR]], i32 0, i32 {{(1|2)}}
// CHECK: [[INIT_EXIST_ADDR:%.*]] = bitcast [32 x i8]* [[VALUE_ADDR]] to %T25existentials_opaque_boxed14FixedOveralignV*
diff --git a/test/IRGen/field_type_vectors.sil b/test/IRGen/field_type_vectors.sil
index da0e894..c9eabdb 100644
--- a/test/IRGen/field_type_vectors.sil
+++ b/test/IRGen/field_type_vectors.sil
@@ -15,7 +15,7 @@
// CHECK-LABEL: @"$S18field_type_vectors3BarVMP" = internal global
// -- There should be 1 word between the field type vector slot, with type %swift.type**,
// and the address point
-// CHECK: %swift.type**, i8**, i64, <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i16, i16, i32 }>*, i64, %swift.type*
+// CHECK: %swift.type**, i8**, i64, <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i16, i16, i32 }>*, %swift.type*, i64
struct Bar<T> {
var y: Int
}
@@ -25,7 +25,7 @@
// CHECK-LABEL: @"$S18field_type_vectors3BasVMP" = internal global
// -- There should be 1 word between the field type vector slot, with type %swift.type**,
// and the address point
-// CHECK: %swift.type**, i8**, i64, <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i16, i16, i32 }>*, i64, i64, %swift.type*, %swift.type*
+// CHECK: %swift.type**, i8**, i64, <{ i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i16, i16, i32 }>*, %swift.type*, %swift.type*, i64, i64
struct Bas<T, U> {
var foo: Foo
var bar: Bar<T>
diff --git a/test/IRGen/function_types.sil b/test/IRGen/function_types.sil
index 18fbf89..1795b5b 100644
--- a/test/IRGen/function_types.sil
+++ b/test/IRGen/function_types.sil
@@ -26,8 +26,8 @@
// CHECK-LABEL: define{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @thick_func_value(i8*, %swift.refcounted*) {{.*}} {
// CHECK-NEXT: entry:
-// CHECK-NEXT: call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* returned %1) {{#[0-9]+}}
-// CHECK-NEXT: call void @swift_rt_swift_release(%swift.refcounted* %1) {{#[0-9]+}}
+// CHECK-NEXT: call %swift.refcounted* @swift_retain(%swift.refcounted* returned %1) {{#[0-9]+}}
+// CHECK-NEXT: call void @swift_release(%swift.refcounted* %1) {{#[0-9]+}}
// CHECK-NEXT: %3 = insertvalue { i8*, %swift.refcounted* } undef, i8* %0, 0
// CHECK-NEXT: %4 = insertvalue { i8*, %swift.refcounted* } %3, %swift.refcounted* %1, 1
// CHECK-NEXT: ret { i8*, %swift.refcounted* } %4
diff --git a/test/IRGen/generic_casts.swift b/test/IRGen/generic_casts.swift
index 1eb1d1d..1459261 100644
--- a/test/IRGen/generic_casts.swift
+++ b/test/IRGen/generic_casts.swift
@@ -45,7 +45,7 @@
// CHECK: [[T_TMP:%.*]] = bitcast i8* [[T_ALLOCA]] to %swift.opaque*
// CHECK: [[TEMP:%.*]] = call %swift.opaque* {{.*}}(%swift.opaque* noalias [[T_TMP]], %swift.opaque* noalias %0, %swift.type* %T)
// CHECK: [[T0:%.*]] = bitcast %TSi* [[INT_TEMP]] to %swift.opaque*
- // CHECK: call i1 @swift_rt_swift_dynamicCast(%swift.opaque* [[T0]], %swift.opaque* [[T_TMP]], %swift.type* %T, %swift.type* @"$SSiN", i64 7)
+ // CHECK: call i1 @swift_dynamicCast(%swift.opaque* [[T0]], %swift.opaque* [[T_TMP]], %swift.type* %T, %swift.type* @"$SSiN", i64 7)
// CHECK: [[T0:%.*]] = getelementptr inbounds %TSi, %TSi* [[INT_TEMP]], i32 0, i32 0
// CHECK: [[INT_RESULT:%.*]] = load i64, i64* [[T0]],
// CHECK: ret i64 [[INT_RESULT]]
@@ -57,7 +57,7 @@
// CHECK: [[T0:%.*]] = getelementptr inbounds %TSi, %TSi* [[INT_TEMP]], i32 0, i32 0
// CHECK: store i64 %1, i64* [[T0]],
// CHECK: [[T0:%.*]] = bitcast %TSi* [[INT_TEMP]] to %swift.opaque*
- // CHECK: call i1 @swift_rt_swift_dynamicCast(%swift.opaque* %0, %swift.opaque* [[T0]], %swift.type* @"$SSiN", %swift.type* %T, i64 7)
+ // CHECK: call i1 @swift_dynamicCast(%swift.opaque* %0, %swift.opaque* [[T0]], %swift.type* @"$SSiN", %swift.type* %T, i64 7)
return x as! T
}
@@ -101,7 +101,7 @@
// CHECK: [[LOCAL:%.*]] = alloca %T13generic_casts10ObjCProto1P
// CHECK: [[LOCAL_OPAQUE:%.*]] = bitcast %T13generic_casts10ObjCProto1P* [[LOCAL]] to %swift.opaque*
// CHECK: [[PROTO_TYPE:%.*]] = call %swift.type* @"$S13generic_casts10ObjCProto1_pMa"()
- // CHECK: call i1 @swift_rt_swift_dynamicCast(%swift.opaque* %0, %swift.opaque* [[LOCAL_OPAQUE]], %swift.type* [[PROTO_TYPE]], %swift.type* %T, i64 7)
+ // CHECK: call i1 @swift_dynamicCast(%swift.opaque* %0, %swift.opaque* [[LOCAL_OPAQUE]], %swift.type* [[PROTO_TYPE]], %swift.type* %T, i64 7)
return x as! T
}
diff --git a/test/IRGen/generic_classes.sil b/test/IRGen/generic_classes.sil
index bdf9683..574a04a 100644
--- a/test/IRGen/generic_classes.sil
+++ b/test/IRGen/generic_classes.sil
@@ -216,7 +216,7 @@
// CHECK: [[T1:%.*]] = bitcast i8* [[T0]] to i16*
// CHECK: [[ALIGN16:%.*]] = load i16, i16* [[T1]], align 4
// CHECK: [[ALIGN:%.*]] = zext i16 [[ALIGN16]] to i64
-// CHECK: call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* [[METADATA]], i64 [[SIZE]], i64 [[ALIGN]])
+// CHECK: call noalias %swift.refcounted* @swift_allocObject(%swift.type* [[METADATA]], i64 [[SIZE]], i64 [[ALIGN]])
sil @RootGeneric_fragile_dependent_alloc : $<G> () -> RootGeneric<G> {
entry:
%x = alloc_ref $RootGeneric<G>
diff --git a/test/IRGen/generic_metatypes.swift b/test/IRGen/generic_metatypes.swift
index 13050c3..54631e0 100644
--- a/test/IRGen/generic_metatypes.swift
+++ b/test/IRGen/generic_metatypes.swift
@@ -110,7 +110,7 @@
// CHECK: [[BUFFER_ELT:%.*]] = getelementptr inbounds { %swift.type* }, { %swift.type* }* [[BUFFER]], i32 0, i32 0
// CHECK: store %swift.type* %0, %swift.type** [[BUFFER_ELT]]
// CHECK: [[BUFFER_PTR:%.*]] = bitcast { %swift.type* }* [[BUFFER]] to i8*
-// CHECK: [[METADATA:%.*]] = call %swift.type* @swift_rt_swift_getGenericMetadata(%swift.type_pattern* {{.*}} @"$S17generic_metatypes6OneArgVMP" {{.*}}, i8* [[BUFFER_PTR]])
+// CHECK: [[METADATA:%.*]] = call %swift.type* @swift_getGenericMetadata(%swift.type_pattern* {{.*}} @"$S17generic_metatypes6OneArgVMP" {{.*}}, i8* [[BUFFER_PTR]])
// CHECK: [[BUFFER_PTR:%.*]] = bitcast { %swift.type* }* [[BUFFER]] to i8*
// CHECK: call void @llvm.lifetime.end
// CHECK: ret %swift.type* [[METADATA]]
@@ -128,7 +128,7 @@
// CHECK: [[BUFFER_ELT:%.*]] = getelementptr inbounds { %swift.type*, %swift.type* }, { %swift.type*, %swift.type* }* [[BUFFER]], i32 0, i32 1
// CHECK: store %swift.type* %1, %swift.type** [[BUFFER_ELT]]
// CHECK: [[BUFFER_PTR:%.*]] = bitcast { %swift.type*, %swift.type* }* [[BUFFER]] to i8*
-// CHECK: [[METADATA:%.*]] = call %swift.type* @swift_rt_swift_getGenericMetadata(%swift.type_pattern* {{.*}} @"$S17generic_metatypes7TwoArgsVMP" {{.*}}, i8* [[BUFFER_PTR]])
+// CHECK: [[METADATA:%.*]] = call %swift.type* @swift_getGenericMetadata(%swift.type_pattern* {{.*}} @"$S17generic_metatypes7TwoArgsVMP" {{.*}}, i8* [[BUFFER_PTR]])
// CHECK: [[BUFFER_PTR:%.*]] = bitcast { %swift.type*, %swift.type* }* [[BUFFER]] to i8*
// CHECK: call void @llvm.lifetime.end
// CHECK: ret %swift.type* [[METADATA]]
@@ -148,7 +148,7 @@
// CHECK: [[BUFFER_ELT:%.*]] = getelementptr inbounds { %swift.type*, %swift.type*, %swift.type* }, { %swift.type*, %swift.type*, %swift.type* }* [[BUFFER]], i32 0, i32 2
// CHECK: store %swift.type* %2, %swift.type** [[BUFFER_ELT]]
// CHECK: [[BUFFER_PTR:%.*]] = bitcast { %swift.type*, %swift.type*, %swift.type* }* [[BUFFER]] to i8*
-// CHECK: [[METADATA:%.*]] = call %swift.type* @swift_rt_swift_getGenericMetadata(%swift.type_pattern* {{.*}} @"$S17generic_metatypes9ThreeArgsVMP" {{.*}}, i8* [[BUFFER_PTR]])
+// CHECK: [[METADATA:%.*]] = call %swift.type* @swift_getGenericMetadata(%swift.type_pattern* {{.*}} @"$S17generic_metatypes9ThreeArgsVMP" {{.*}}, i8* [[BUFFER_PTR]])
// CHECK: [[BUFFER_PTR:%.*]] = bitcast { %swift.type*, %swift.type*, %swift.type* }* [[BUFFER]] to i8*
// CHECK: call void @llvm.lifetime.end
// CHECK: ret %swift.type* [[METADATA]]
@@ -170,7 +170,7 @@
// CHECK: define hidden %swift.type* @"$S17generic_metatypes8FiveArgsVMa"(%swift.type*, %swift.type*, %swift.type*, i8**) [[NOUNWIND_OPT:#[0-9]+]]
// CHECK-NOT: alloc
-// CHECK: call %swift.type* @swift_rt_swift_getGenericMetadata(%swift.type_pattern* {{.*}} @"$S17generic_metatypes8FiveArgsVMP" {{.*}}, i8*
+// CHECK: call %swift.type* @swift_getGenericMetadata(%swift.type_pattern* {{.*}} @"$S17generic_metatypes8FiveArgsVMP" {{.*}}, i8*
// CHECK-NOT: call void @llvm.lifetime.end
// CHECK: ret %swift.type*
diff --git a/test/IRGen/generic_metatypes_arm.swift b/test/IRGen/generic_metatypes_arm.swift
index 1f2d6d0..4812e9c 100644
--- a/test/IRGen/generic_metatypes_arm.swift
+++ b/test/IRGen/generic_metatypes_arm.swift
@@ -108,7 +108,7 @@
// CHECK: [[BUFFER_ELT:%.*]] = getelementptr inbounds { %swift.type* }, { %swift.type* }* [[BUFFER]], i32 0, i32 0
// CHECK: store %swift.type* %0, %swift.type** [[BUFFER_ELT]]
// CHECK: [[BUFFER_PTR:%.*]] = bitcast { %swift.type* }* [[BUFFER]] to i8*
-// CHECK: [[METADATA:%.*]] = call %swift.type* @swift_rt_swift_getGenericMetadata(%swift.type_pattern* {{.*}} @"$S17generic_metatypes6OneArgVMP" {{.*}}, i8* [[BUFFER_PTR]])
+// CHECK: [[METADATA:%.*]] = call %swift.type* @swift_getGenericMetadata(%swift.type_pattern* {{.*}} @"$S17generic_metatypes6OneArgVMP" {{.*}}, i8* [[BUFFER_PTR]])
// CHECK: [[BUFFER_PTR:%.*]] = bitcast { %swift.type* }* [[BUFFER]] to i8*
// CHECK: call void @llvm.lifetime.end
// CHECK: ret %swift.type* [[METADATA]]
@@ -126,7 +126,7 @@
// CHECK: [[BUFFER_ELT:%.*]] = getelementptr inbounds { %swift.type*, %swift.type* }, { %swift.type*, %swift.type* }* [[BUFFER]], i32 0, i32 1
// CHECK: store %swift.type* %1, %swift.type** [[BUFFER_ELT]]
// CHECK: [[BUFFER_PTR:%.*]] = bitcast { %swift.type*, %swift.type* }* [[BUFFER]] to i8*
-// CHECK: [[METADATA:%.*]] = call %swift.type* @swift_rt_swift_getGenericMetadata(%swift.type_pattern* {{.*}} @"$S17generic_metatypes7TwoArgsVMP" {{.*}}, i8* [[BUFFER_PTR]])
+// CHECK: [[METADATA:%.*]] = call %swift.type* @swift_getGenericMetadata(%swift.type_pattern* {{.*}} @"$S17generic_metatypes7TwoArgsVMP" {{.*}}, i8* [[BUFFER_PTR]])
// CHECK: [[BUFFER_PTR:%.*]] = bitcast { %swift.type*, %swift.type* }* [[BUFFER]] to i8*
// CHECK: call void @llvm.lifetime.end
// CHECK: ret %swift.type* [[METADATA]]
@@ -146,7 +146,7 @@
// CHECK: [[BUFFER_ELT:%.*]] = getelementptr inbounds { %swift.type*, %swift.type*, %swift.type* }, { %swift.type*, %swift.type*, %swift.type* }* [[BUFFER]], i32 0, i32 2
// CHECK: store %swift.type* %2, %swift.type** [[BUFFER_ELT]]
// CHECK: [[BUFFER_PTR:%.*]] = bitcast { %swift.type*, %swift.type*, %swift.type* }* [[BUFFER]] to i8*
-// CHECK: [[METADATA:%.*]] = call %swift.type* @swift_rt_swift_getGenericMetadata(%swift.type_pattern* {{.*}} @"$S17generic_metatypes9ThreeArgsVMP" {{.*}}, i8* [[BUFFER_PTR]])
+// CHECK: [[METADATA:%.*]] = call %swift.type* @swift_getGenericMetadata(%swift.type_pattern* {{.*}} @"$S17generic_metatypes9ThreeArgsVMP" {{.*}}, i8* [[BUFFER_PTR]])
// CHECK: [[BUFFER_PTR:%.*]] = bitcast { %swift.type*, %swift.type*, %swift.type* }* [[BUFFER]] to i8*
// CHECK: call void @llvm.lifetime.end
// CHECK: ret %swift.type* [[METADATA]]
@@ -157,7 +157,7 @@
// CHECK-LABEL: define hidden %swift.type* @"$S17generic_metatypes8FourArgsVMa"(%swift.type*, %swift.type*, %swift.type*, i8**)
// CHECK-NOT: alloc
-// CHECK: call %swift.type* @swift_rt_swift_getGenericMetadata(
+// CHECK: call %swift.type* @swift_getGenericMetadata(
// CHECK-NOT: call void @llvm.lifetime.end
// CHECK: ret %swift.type*
@@ -167,7 +167,7 @@
// CHECK-LABEL: define hidden %swift.type* @"$S17generic_metatypes8FiveArgsVMa"(%swift.type*, %swift.type*, %swift.type*, i8**)
// CHECK-NOT: alloca
-// CHECK: call %swift.type* @swift_rt_swift_getGenericMetadata(%swift.type_pattern* {{.*}} @"$S17generic_metatypes8FiveArgsVMP" {{.*}}, i8*
+// CHECK: call %swift.type* @swift_getGenericMetadata(%swift.type_pattern* {{.*}} @"$S17generic_metatypes8FiveArgsVMP" {{.*}}, i8*
// CHECK-NOT: call void @llvm.lifetime.end
// CHECK: ret %swift.type*
diff --git a/test/IRGen/generic_structs.sil b/test/IRGen/generic_structs.sil
index c83ce1a..a194afb 100644
--- a/test/IRGen/generic_structs.sil
+++ b/test/IRGen/generic_structs.sil
@@ -25,13 +25,13 @@
// -- field count
// CHECK-SAME: i32 1,
// -- field offset vector offset
-// CHECK-SAME: i32 2,
+// CHECK-SAME: i32 3,
// -- field names
// CHECK-SAME: [3 x i8]* [[SINGLEDYNAMIC_FIELDS]]
// -- kind 1 (struct)
// CHECK-SAME: i32 1
// -- generic parameter vector offset
-// CHECK-SAME: i32 3,
+// CHECK-SAME: i32 2,
// -- generic parameter count, primary count
// CHECK-SAME: i32 1, i32 1
// -- nesting depth
@@ -50,7 +50,7 @@
// -- address point
// CHECK-SAME: i64 1, {{.*}}* @"$S15generic_structs13SingleDynamicVMn"
// -- field offset vector; generic parameter vector
-// CHECK-SAME: i64 0, %swift.type* null }>
+// CHECK-SAME: %swift.type* null, i64 0 }>
// -- Nominal type descriptor for generic struct with protocol requirements
// FIXME: Strings should be unnamed_addr. rdar://problem/22674524
@@ -62,13 +62,13 @@
// -- field count
// CHECK-SAME: i32 2,
// -- field offset vector offset
-// CHECK-SAME: i32 2,
+// CHECK-SAME: i32 6,
// -- field names
// CHECK-SAME: [5 x i8]* [[DYNAMICWITHREQUIREMENTS_FIELDS]]
// -- kind 1 (struct)
// CHECK-SAME: i32 1,
// -- generic parameter vector offset
-// CHECK-SAME: i32 4,
+// CHECK-SAME: i32 2,
// -- generic requirements count; generic arguments count
// CHECK-SAME: i32 4, i32 2
// -- nesting depth
@@ -81,7 +81,7 @@
// CHECK: @"$S15generic_structs23DynamicWithRequirementsVMP" = internal global <{ {{.*}} }> <{
// -- field offset vector; generic parameter vector
-// CHECK: i64 0, i64 0, %swift.type* null, %swift.type* null, i8** null, i8** null }>
+// CHECK: %swift.type* null, %swift.type* null, i8** null, i8** null, i64 0, i64 0 }>
// -- Fixed-layout struct metadata contains fixed field offsets
// CHECK: @"$S15generic_structs6IntishVMf" = internal constant <{ {{.*}} i64 }> <{
@@ -144,7 +144,7 @@
%a = struct_element_addr %0 : $*ComplexDynamic<A, B>, #ComplexDynamic.a2
// CHECK: [[METADATA:%.*]] = bitcast %swift.type* {{%.*}} to i64*
- // CHECK: [[FIELD_OFFSET_VECTOR:%.*]] = getelementptr inbounds i64, i64* [[METADATA]], i64 2
+ // CHECK: [[FIELD_OFFSET_VECTOR:%.*]] = getelementptr inbounds i64, i64* [[METADATA]], i64 4
// CHECK: [[FIELD_OFFSET_ADDR:%.*]] = getelementptr inbounds i64, i64* [[FIELD_OFFSET_VECTOR]], i32 2
// CHECK: [[FIELD_OFFSET:%.*]] = load i64, i64* [[FIELD_OFFSET_ADDR]], align 8
// CHECK: [[BYTES:%.*]] = bitcast %T15generic_structs14ComplexDynamicV* %0 to i8*
@@ -153,7 +153,7 @@
%b = struct_element_addr %0 : $*ComplexDynamic<A, B>, #ComplexDynamic.b
// CHECK: [[METADATA:%.*]] = bitcast %swift.type* {{%.*}} to i64*
- // CHECK: [[FIELD_OFFSET_VECTOR:%.*]] = getelementptr inbounds i64, i64* [[METADATA]], i64 2
+ // CHECK: [[FIELD_OFFSET_VECTOR:%.*]] = getelementptr inbounds i64, i64* [[METADATA]], i64 4
// CHECK: [[FIELD_OFFSET_ADDR:%.*]] = getelementptr inbounds i64, i64* [[FIELD_OFFSET_VECTOR]], i32 3
// CHECK: [[FIELD_OFFSET:%.*]] = load i64, i64* [[FIELD_OFFSET_ADDR]], align 8
// CHECK: [[BYTES:%.*]] = bitcast %T15generic_structs14ComplexDynamicV* %0 to i8*
@@ -163,7 +163,7 @@
%c = struct_element_addr %5 : $*SingleDynamic<B>, #SingleDynamic.x
// CHECK: [[METADATA:%.*]] = bitcast %swift.type* {{%.*}} to i64*
- // CHECK: [[FIELD_OFFSET_VECTOR:%.*]] = getelementptr inbounds i64, i64* [[METADATA]], i64 2
+ // CHECK: [[FIELD_OFFSET_VECTOR:%.*]] = getelementptr inbounds i64, i64* [[METADATA]], i64 4
// CHECK: [[FIELD_OFFSET_ADDR:%.*]] = getelementptr inbounds i64, i64* [[FIELD_OFFSET_VECTOR]], i32 4
// CHECK: [[FIELD_OFFSET:%.*]] = load i64, i64* [[FIELD_OFFSET_ADDR]], align 8
// CHECK: [[BYTES:%.*]] = bitcast %T15generic_structs14ComplexDynamicV* %0 to i8*
@@ -214,12 +214,12 @@
// CHECK: [[METADATA:%.*]] = call %swift.type* @swift_allocateGenericValueMetadata(%swift.type_pattern* %0, i8** %1)
// CHECK: [[SELF_ARRAY:%.*]] = bitcast %swift.type* [[METADATA]] to i8**
// Fill type argument.
-// CHECK: [[T1:%.*]] = getelementptr inbounds i8*, i8** [[SELF_ARRAY]], i64 3
+// CHECK: [[T1:%.*]] = getelementptr inbounds i8*, i8** [[SELF_ARRAY]], i64 2
// CHECK: [[T0:%.*]] = bitcast %swift.type* %T to i8*
// CHECK: store i8* [[T0]], i8** [[T1]], align 8
// Lay out fields.
// CHECK: [[T0:%.*]] = bitcast %swift.type* [[METADATA]] to i64*
-// CHECK: [[T1:%.*]] = getelementptr inbounds i64, i64* [[T0]], i64 2
+// CHECK: [[T1:%.*]] = getelementptr inbounds i64, i64* [[T0]], i64 3
// CHECK: [[T2:%.*]] = getelementptr inbounds i8**, i8*** [[TYPES:%.*]], i32 0
// CHECK: call void @swift_initStructMetadata(%swift.type* [[METADATA]], i64 0, i64 1, i8*** [[TYPES]], i64* [[T1]])
// CHECK: ret %swift.type* [[METADATA]]
diff --git a/test/IRGen/generic_structs.swift b/test/IRGen/generic_structs.swift
index ee29841..86963d9 100644
--- a/test/IRGen/generic_structs.swift
+++ b/test/IRGen/generic_structs.swift
@@ -41,7 +41,7 @@
// CHECK-32-LABEL: define{{.*}} swiftcc void @"$S15generic_structs13GenericStructVACyxGycfC"
// CHECK-32: [[TYPE:%.*]] = call %swift.type* @"$S15generic_structs13GenericStructVMa"(%swift.type* %T, i8** %T.Proto)
// CHECK-32: [[PTR:%.*]] = bitcast %swift.type* [[TYPE]] to i32*
-// CHECK-32: [[FIELDOFFSETS:%.*]] = getelementptr inbounds i32, i32* [[PTR]], i32 2
+// CHECK-32: [[FIELDOFFSETS:%.*]] = getelementptr inbounds i32, i32* [[PTR]], i32 4
// CHECK-32: [[FIELDOFFSET:%.*]] = getelementptr inbounds i32, i32* [[FIELDOFFSETS]], i32 2
// CHECK-32: [[OFFSET:%.*]] = load i32, i32* [[FIELDOFFSET]]
// CHECK-32: [[ADDROFOPT:%.*]] = getelementptr inbounds i8, i8* {{.*}}, i32 [[OFFSET]]
@@ -51,7 +51,7 @@
// CHECK-64-LABEL: define{{.*}} swiftcc void @"$S15generic_structs13GenericStructVACyxGycfC"
// CHECK-64: [[TYPE:%.*]] = call %swift.type* @"$S15generic_structs13GenericStructVMa"(%swift.type* %T, i8** %T.Proto)
// CHECK-64: [[PTR:%.*]] = bitcast %swift.type* [[TYPE]] to i64*
-// CHECK-64: [[FIELDOFFSETS:%.*]] = getelementptr inbounds i64, i64* [[PTR]], i64 2
+// CHECK-64: [[FIELDOFFSETS:%.*]] = getelementptr inbounds i64, i64* [[PTR]], i64 4
// CHECK-64: [[FIELDOFFSET:%.*]] = getelementptr inbounds i64, i64* [[FIELDOFFSETS]], i32 2
// CHECK-64: [[OFFSET:%.*]] = load i64, i64* [[FIELDOFFSET]]
// CHECK-64: [[ADDROFOPT:%.*]] = getelementptr inbounds i8, i8* {{.*}}, i64 [[OFFSET]]
diff --git a/test/IRGen/generic_tuples.swift b/test/IRGen/generic_tuples.swift
index dbd12c0..8b0cb23 100644
--- a/test/IRGen/generic_tuples.swift
+++ b/test/IRGen/generic_tuples.swift
@@ -49,7 +49,7 @@
// CHECK-LABEL: define hidden swiftcc { %T14generic_tuples1CC*, %T14generic_tuples1CC* } @"$S14generic_tuples4dupCyx_xtxAA1CCRbzlF"(%T14generic_tuples1CC*, %swift.type* %T)
// CHECK-NEXT: entry:
// CHECK: [[REF:%.*]] = bitcast %T14generic_tuples1CC* %0 to %swift.refcounted*
-// CHECK-NEXT: call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* returned [[REF]])
+// CHECK-NEXT: call %swift.refcounted* @swift_retain(%swift.refcounted* returned [[REF]])
// CHECK-NEXT: [[TUP1:%.*]] = insertvalue { %T14generic_tuples1CC*, %T14generic_tuples1CC* } undef, %T14generic_tuples1CC* %0, 0
// CHECK-NEXT: [[TUP2:%.*]] = insertvalue { %T14generic_tuples1CC*, %T14generic_tuples1CC* } [[TUP1:%.*]], %T14generic_tuples1CC* %0, 1
// CHECK-NEXT: ret { %T14generic_tuples1CC*, %T14generic_tuples1CC* } [[TUP2]]
@@ -58,20 +58,20 @@
// CHECK-LABEL: define hidden swiftcc void @"$S14generic_tuples8callDupCyyAA1CCF"(%T14generic_tuples1CC*)
// CHECK-NEXT: entry:
// CHECK-NEXT: [[REF:%.*]] = bitcast %T14generic_tuples1CC* %0 to %swift.refcounted*
-// CHECK-NEXT: call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* returned [[REF]])
+// CHECK-NEXT: call %swift.refcounted* @swift_retain(%swift.refcounted* returned [[REF]])
// CHECK-NEXT: [[METATYPE:%.*]] = call %swift.type* @"$S14generic_tuples1CCMa"()
// CHECK-NEXT: [[TUPLE:%.*]] = call swiftcc { %T14generic_tuples1CC*, %T14generic_tuples1CC* } @"$S14generic_tuples4dupCyx_xtxAA1CCRbzlF"(%T14generic_tuples1CC* %0, %swift.type* [[METATYPE]])
// CHECK-NEXT: [[LEFT:%.*]] = extractvalue { %T14generic_tuples1CC*, %T14generic_tuples1CC* } [[TUPLE]], 0
// CHECK-NEXT: [[RIGHT:%.*]] = extractvalue { %T14generic_tuples1CC*, %T14generic_tuples1CC* } [[TUPLE]], 1
// CHECK-NEXT: [[LEFT_CAST:%.*]] = bitcast %T14generic_tuples1CC* [[LEFT]] to %swift.refcounted*
-// CHECK-NEXT: call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* returned [[LEFT_CAST]]
+// CHECK-NEXT: call %swift.refcounted* @swift_retain(%swift.refcounted* returned [[LEFT_CAST]]
// CHECK-NEXT: [[RIGHT_CAST:%.*]] = bitcast %T14generic_tuples1CC* [[RIGHT]] to %swift.refcounted*
-// CHECK-NEXT: call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* returned [[RIGHT_CAST]]
-// CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_rt_swift_release to void (%T14generic_tuples1CC*)*)(%T14generic_tuples1CC* [[LEFT]])
-// CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_rt_swift_release to void (%T14generic_tuples1CC*)*)(%T14generic_tuples1CC* [[RIGHT]])
-// CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_rt_swift_release to void (%T14generic_tuples1CC*)*)(%T14generic_tuples1CC* [[RIGHT]])
-// CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_rt_swift_release to void (%T14generic_tuples1CC*)*)(%T14generic_tuples1CC* [[LEFT]])
-// CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_rt_swift_release to void (%T14generic_tuples1CC*)*)(%T14generic_tuples1CC* %0)
+// CHECK-NEXT: call %swift.refcounted* @swift_retain(%swift.refcounted* returned [[RIGHT_CAST]]
+// CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T14generic_tuples1CC*)*)(%T14generic_tuples1CC* [[LEFT]])
+// CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T14generic_tuples1CC*)*)(%T14generic_tuples1CC* [[RIGHT]])
+// CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T14generic_tuples1CC*)*)(%T14generic_tuples1CC* [[RIGHT]])
+// CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T14generic_tuples1CC*)*)(%T14generic_tuples1CC* [[LEFT]])
+// CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T14generic_tuples1CC*)*)(%T14generic_tuples1CC* %0)
// CHECK-NEXT: ret void
// CHECK: define hidden swiftcc i64 @"$S14generic_tuples4lumpySi_xxtxlF"(%swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.opaque* noalias nocapture, %swift.type* %T)
diff --git a/test/IRGen/generic_types.swift b/test/IRGen/generic_types.swift
index f071062..b9d2540 100644
--- a/test/IRGen/generic_types.swift
+++ b/test/IRGen/generic_types.swift
@@ -115,7 +115,7 @@
// CHECK: %T = load %swift.type*, %swift.type** [[T0]],
// CHECK-native: [[METADATA:%.*]] = call %swift.type* @swift_allocateGenericClassMetadata(%swift.type_pattern* %0, i8** %1, %objc_class* null, i64 7)
// CHECK-objc: [[T0:%.*]] = load %objc_class*, %objc_class** @"OBJC_CLASS_REF_$__TtCs12_SwiftObject"
-// CHECK-objc: [[SUPER:%.*]] = call %objc_class* @swift_rt_swift_getInitializedObjCClass(%objc_class* [[T0]])
+// CHECK-objc: [[SUPER:%.*]] = call %objc_class* @swift_getInitializedObjCClass(%objc_class* [[T0]])
// CHECK-objc: [[METADATA:%.*]] = call %swift.type* @swift_allocateGenericClassMetadata(%swift.type_pattern* %0, i8** %1, %objc_class* [[SUPER]], i64 7)
// CHECK: [[SELF_ARRAY:%.*]] = bitcast %swift.type* [[METADATA]] to i8**
// CHECK: [[T1:%.*]] = getelementptr inbounds i8*, i8** [[SELF_ARRAY]], i64 10
@@ -129,7 +129,7 @@
// CHECK: %T = load %swift.type*, %swift.type** [[T0]],
// CHECK-native: [[METADATA:%.*]] = call %swift.type* @swift_allocateGenericClassMetadata(%swift.type_pattern* %0, i8** %1, %objc_class* null, i64 6)
// CHECK-objc: [[T0:%.*]] = load %objc_class*, %objc_class** @"OBJC_CLASS_REF_$__TtCs12_SwiftObject"
-// CHECK-objc: [[SUPER:%.*]] = call %objc_class* @swift_rt_swift_getInitializedObjCClass(%objc_class* [[T0]])
+// CHECK-objc: [[SUPER:%.*]] = call %objc_class* @swift_getInitializedObjCClass(%objc_class* [[T0]])
// CHECK-objc: [[METADATA:%.*]] = call %swift.type* @swift_allocateGenericClassMetadata(%swift.type_pattern* %0, i8** %1, %objc_class* [[SUPER]], i64 6)
// CHECK: [[SELF_ARRAY:%.*]] = bitcast %swift.type* [[METADATA]] to i8**
// CHECK: [[T1:%.*]] = getelementptr inbounds i8*, i8** [[SELF_ARRAY]], i64 10
diff --git a/test/IRGen/global_resilience.sil b/test/IRGen/global_resilience.sil
index 7d4635d..d66c1f0 100644
--- a/test/IRGen/global_resilience.sil
+++ b/test/IRGen/global_resilience.sil
@@ -73,7 +73,7 @@
// CHECK-LABEL: define{{( protected)?}} swiftcc void @testLargeGlobal()
sil @testLargeGlobal : $@convention(thin) () -> () {
bb0:
- // CHECK: [[ALLOC:%.*]] = call noalias i8* @swift_rt_swift_slowAlloc([[INT]] 32, [[INT]] 7)
+ // CHECK: [[ALLOC:%.*]] = call noalias i8* @swift_slowAlloc([[INT]] 32, [[INT]] 7)
// CHECK: store i8* [[ALLOC]], i8** bitcast ([[BUFFER]]* @largeGlobal to i8**), align 1
alloc_global @largeGlobal
@@ -139,7 +139,7 @@
// CHECK: [[SIZEWITNESS:%.*]] = load i8*, i8** [[SIZE_ADDR]]
// CHECK: [[SIZE:%.*]] = ptrtoint i8* [[SIZEWITNESS]]
// CHECK: [[ALIGN:%.*]] = and {{.*}} [[FLAGS]], 65535
-// CHECK: [[PTR:%.*]] = call noalias i8* @swift_rt_swift_slowAlloc({{.*}} [[SIZE]], {{.*}} [[ALIGN]])
+// CHECK: [[PTR:%.*]] = call noalias i8* @swift_slowAlloc({{.*}} [[SIZE]], {{.*}} [[ALIGN]])
// CHECK: [[ADDR:%.*]] = bitcast %swift.opaque* %1 to i8**
// CHECK: store i8* [[PTR]], i8** [[ADDR]]
// CHECK: [[OUTLINEADDR:%.*]] = bitcast i8* [[PTR]] to %swift.opaque*
diff --git a/test/IRGen/indirect_argument.sil b/test/IRGen/indirect_argument.sil
index 595c5aa..6a6e8f9 100644
--- a/test/IRGen/indirect_argument.sil
+++ b/test/IRGen/indirect_argument.sil
@@ -64,7 +64,7 @@
// CHECK-LABEL: define{{( protected)?}} swiftcc void @huge_partial_application(%T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}}), %T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}}))
// CHECK-NOT: alloca
-// CHECK: [[CLOSURE:%.*]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject
+// CHECK: [[CLOSURE:%.*]] = call noalias %swift.refcounted* @swift_allocObject
// CHECK: bitcast %swift.refcounted* [[CLOSURE]] to <{ %swift.refcounted, %T17indirect_argument4HugeV }>*
// CHECK: call swiftcc void @"$S24huge_partial_applicationTA"(%T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}}) %0, %swift.refcounted* swiftself [[CLOSURE]])
// CHECK: define internal swiftcc void @"$S24huge_partial_applicationTA"(%T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}}), %swift.refcounted* swiftself)
@@ -81,7 +81,7 @@
// CHECK-LABEL: define{{( protected)?}} swiftcc void @huge_partial_application_stret(%T17indirect_argument4HugeV* noalias nocapture sret, %T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}}), %T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}}))
// CHECK: [[TMP_RET:%.*]] = alloca
-// CHECK: [[CLOSURE:%.*]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject
+// CHECK: [[CLOSURE:%.*]] = call noalias %swift.refcounted* @swift_allocObject
// CHECK: bitcast %swift.refcounted* [[CLOSURE]] to <{ %swift.refcounted, %T17indirect_argument4HugeV }>*
// CHECK: call swiftcc void @"$S30huge_partial_application_stretTA"(%T17indirect_argument4HugeV* noalias nocapture sret [[TMP_RET]], %T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}}) %1, %swift.refcounted* swiftself [[CLOSURE]])
// CHECK: define internal swiftcc void @"$S30huge_partial_application_stretTA"(%T17indirect_argument4HugeV* noalias nocapture sret, %T17indirect_argument4HugeV* noalias nocapture dereferenceable({{.*}}), %swift.refcounted* swiftself)
diff --git a/test/IRGen/keypaths.sil b/test/IRGen/keypaths.sil
index 6acd9a1..e83f7e3 100644
--- a/test/IRGen/keypaths.sil
+++ b/test/IRGen/keypaths.sil
@@ -200,8 +200,8 @@
// CHECK-64-SAME: [4 x i8] zeroinitializer,
// -- struct with runtime-resolved offset
// CHECK-SAME: <i32 0x1ffffffe>,
-// CHECK-32-SAME: i32 8 }>
-// CHECK-64-SAME: i32 16 }>
+// CHECK-32-SAME: i32 16 }>
+// CHECK-64-SAME: i32 32 }>
// -- %j: Gen<A>.y
// CHECK: [[KP_J:@keypath.*]] = private global <{ {{.*}} }> <{
@@ -213,8 +213,8 @@
// CHECK-64-SAME: [4 x i8] zeroinitializer,
// -- struct with runtime-resolved offset
// CHECK-SAME: <i32 0x1ffffffe>,
-// CHECK-32-SAME: i32 12 }>
-// CHECK-64-SAME: i32 24 }>
+// CHECK-32-SAME: i32 20 }>
+// CHECK-64-SAME: i32 40 }>
// CHECK-LABEL: define{{( protected)?}} swiftcc void @stored_property_fixed_offsets()
sil @stored_property_fixed_offsets : $@convention(thin) () -> () {
diff --git a/test/IRGen/metadata_dominance.swift b/test/IRGen/metadata_dominance.swift
index dbb6037..b66e1e0 100644
--- a/test/IRGen/metadata_dominance.swift
+++ b/test/IRGen/metadata_dominance.swift
@@ -80,5 +80,5 @@
// conformance metadata_dominance.Foo : metadata_dominance.P should not use the Self type
// as the type of the object to be created. It should dynamically obtain the type.
// CHECK-OPT-LABEL: define internal swiftcc %T18metadata_dominance3FooC* @"$S18metadata_dominance3FooCAA1PA2aDP04makeC0ACyFTW"
-// CHECK-OPT-NOT: tail call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* %Self
+// CHECK-OPT-NOT: tail call noalias %swift.refcounted* @swift_allocObject(%swift.type* %Self
diff --git a/test/IRGen/mixed_mode_class_with_unimportable_fields.sil b/test/IRGen/mixed_mode_class_with_unimportable_fields.sil
index f75809f..0d6d826 100644
--- a/test/IRGen/mixed_mode_class_with_unimportable_fields.sil
+++ b/test/IRGen/mixed_mode_class_with_unimportable_fields.sil
@@ -33,13 +33,13 @@
// CHECK-32: [[SIZE:%.*]] = load i32
// CHECK: [[ALIGN16:%.*]] = load i16
// CHECK: [[ALIGN:%.*]] = zext i16 [[ALIGN16]] to [[WORD:i32|i64]]
- // CHECK: call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* [[METADATA]], [[WORD]] [[SIZE]], [[WORD]] [[ALIGN]])
+ // CHECK: call noalias %swift.refcounted* @swift_allocObject(%swift.type* [[METADATA]], [[WORD]] [[SIZE]], [[WORD]] [[ALIGN]])
%x = alloc_ref $ButtHolder
// CHECK: [[METADATA:%.*]] = call %swift.type* @"$S4main13SubButtHolderCMa"()
- // CHECK: call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* [[METADATA]], [[WORD]] %{{.*}}, [[WORD]] %{{.*}})
+ // CHECK: call noalias %swift.refcounted* @swift_allocObject(%swift.type* [[METADATA]], [[WORD]] %{{.*}}, [[WORD]] %{{.*}})
%y = alloc_ref $SubButtHolder
// CHECK: [[METADATA:%.*]] = call %swift.type* @"$S4main03SubB10ButtHolderCMa"()
- // CHECK: call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* [[METADATA]], [[WORD]] %{{.*}}, [[WORD]] %{{.*}})
+ // CHECK: call noalias %swift.refcounted* @swift_allocObject(%swift.type* [[METADATA]], [[WORD]] %{{.*}}, [[WORD]] %{{.*}})
%z = alloc_ref $SubSubButtHolder
return %x : $ButtHolder
}
diff --git a/test/IRGen/nonatomic_reference_counting.sil b/test/IRGen/nonatomic_reference_counting.sil
index cb8a056..a3238c5 100644
--- a/test/IRGen/nonatomic_reference_counting.sil
+++ b/test/IRGen/nonatomic_reference_counting.sil
@@ -33,8 +33,8 @@
sil @doSomething : $@convention(thin) () -> ()
// CHECK-LABEL: define {{.*}}@test_strong_nonatomic_rr
-// CHECK: call {{.*}}@swift_rt_swift_nonatomic_retain
-// CHECK: call {{.*}}@swift_rt_swift_nonatomic_release
+// CHECK: call {{.*}}@swift_nonatomic_retain
+// CHECK: call {{.*}}@swift_nonatomic_release
// CHECK: ret
sil @test_strong_nonatomic_rr: $@convention(thin) () -> @owned C {
bb0:
@@ -47,8 +47,8 @@
}
// CHECK-LABEL: define {{.*}}@test_unknown_nonatomic_rr
-// CHECK: call {{.*}}@{{(swift_nonatomic_unknownRetain|swift_rt_swift_nonatomic_retain)}}
-// CHECK: call {{.*}}@{{(swift_nonatomic_unknownRelease|swift_rt_swift_nonatomic_release)}}
+// CHECK: call {{.*}}@{{(swift_nonatomic_unknownRetain|swift_nonatomic_retain)}}
+// CHECK: call {{.*}}@{{(swift_nonatomic_unknownRelease|swift_nonatomic_release)}}
// CHECK: ret
sil @test_unknown_nonatomic_rr: $@convention(thin) <T where T : P> (@owned T) -> () {
bb0(%0 : $T):
@@ -61,8 +61,8 @@
}
// CHECK-LABEL: define {{.*}}@test_strong_nonatomic_rr_n
-// CHECK: call {{.*}}@swift_rt_swift_nonatomic_retain_n
-// CHECK: call {{.*}}@swift_rt_swift_nonatomic_release_n
+// CHECK: call {{.*}}@swift_nonatomic_retain_n
+// CHECK: call {{.*}}@swift_nonatomic_release_n
// CHECK: ret
sil @test_strong_nonatomic_rr_n: $@convention(thin) () -> @owned C {
bb0:
@@ -77,8 +77,8 @@
}
// CHECK-LABEL: define {{.*}}@test_strong_mixed_rr_n
-// CHECK: call {{.*}}@swift_rt_swift_retain_n
-// CHECK: call {{.*}}@swift_rt_swift_release_n
+// CHECK: call {{.*}}@swift_retain_n
+// CHECK: call {{.*}}@swift_release_n
// CHECK: ret
sil @test_strong_mixed_rr_n: $@convention(thin) () -> @owned C {
bb0:
@@ -93,8 +93,8 @@
}
// CHECK-LABEL: define {{.*}}@test_unknown_nonatomic_rr_n
-// CHECK: call {{.*}}@{{(swift_nonatomic_unknownRetain_n|swift_rt_swift_nonatomic_retain_n)}}
-// CHECK: call {{.*}}@{{(swift_nonatomic_unknownRelease_n|swift_rt_swift_nonatomic_release_n)}}
+// CHECK: call {{.*}}@{{(swift_nonatomic_unknownRetain_n|swift_nonatomic_retain_n)}}
+// CHECK: call {{.*}}@{{(swift_nonatomic_unknownRelease_n|swift_nonatomic_release_n)}}
// CHECK: ret
sil @test_unknown_nonatomic_rr_n: $@convention(thin) <T where T : P> (@owned T) -> () {
bb0(%0 : $T):
@@ -109,8 +109,8 @@
}
// CHECK-LABEL: define {{.*}}@test_unknown_mixed_rr_n
-// CHECK: call {{.*}}@{{(swift_unknownRetain_n|swift_rt_swift_retain_n)}}
-// CHECK: call {{.*}}@{{(swift_unknownRelease_n|swift_rt_swift_release_n)}}
+// CHECK: call {{.*}}@{{(swift_unknownRetain_n|swift_retain_n)}}
+// CHECK: call {{.*}}@{{(swift_unknownRelease_n|swift_release_n)}}
// CHECK: ret
sil @test_unknown_mixed_rr_n: $@convention(thin) <T where T : P> (@owned T) -> () {
bb0(%0 : $T):
@@ -196,8 +196,8 @@
}
// CHECK-LABEL: define {{.*}}@test_nonatomic_pin_unpin
-// CHECK: call {{.*}}@swift_rt_swift_nonatomic_tryPin
-// CHECK: call {{.*}}@swift_rt_swift_nonatomic_unpin
+// CHECK: call {{.*}}@swift_nonatomic_tryPin
+// CHECK: call {{.*}}@swift_nonatomic_unpin
// CHECK: ret
sil @test_nonatomic_pin_unpin: $@convention(thin) () -> () {
bb0:
diff --git a/test/IRGen/objc.swift b/test/IRGen/objc.swift
index 1d955a1..ec4d58a 100644
--- a/test/IRGen/objc.swift
+++ b/test/IRGen/objc.swift
@@ -39,7 +39,7 @@
class MyBlammo : Blammo {
func foo() {}
// CHECK: define hidden swiftcc void @"$S4objc8MyBlammoC3fooyyF"([[MYBLAMMO]]* swiftself) {{.*}} {
-// CHECK: call {{.*}} @swift_rt_swift_release
+// CHECK: call {{.*}} @swift_release
// CHECK: ret void
}
@@ -87,7 +87,7 @@
func test1(_ cell: Blammo) {}
// CHECK: define hidden swiftcc void @"$S4objc5test1{{[_0-9a-zA-Z]*}}F"([[BLAMMO]]*) {{.*}} {
-// CHECK: call {{.*}} @swift_rt_swift_release
+// CHECK: call {{.*}} @swift_release
// CHECK: ret void
diff --git a/test/IRGen/objc_block_storage.sil b/test/IRGen/objc_block_storage.sil
index 256752f..40861f6 100644
--- a/test/IRGen/objc_block_storage.sil
+++ b/test/IRGen/objc_block_storage.sil
@@ -134,7 +134,7 @@
// CHECK-NEXT: %2 = getelementptr inbounds { %objc_block, %swift.refcounted* }, { %objc_block, %swift.refcounted* }* %0, i32 0, i32 1
// CHECK-NEXT: %3 = getelementptr inbounds { %objc_block, %swift.refcounted* }, { %objc_block, %swift.refcounted* }* %1, i32 0, i32 1
// CHECK-NEXT: %4 = load %swift.refcounted*, %swift.refcounted** %3, align 8
-// CHECK-NEXT: call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* returned %4) {{#[0-9]+}}
+// CHECK-NEXT: call %swift.refcounted* @swift_retain(%swift.refcounted* returned %4) {{#[0-9]+}}
// CHECK-NEXT: store %swift.refcounted* %4, %swift.refcounted** %2, align 8
// CHECK-NEXT: ret void
@@ -142,7 +142,7 @@
// CHECK-NEXT: entry:
// CHECK-NEXT: %1 = getelementptr inbounds { %objc_block, %swift.refcounted* }, { %objc_block, %swift.refcounted* }* %0, i32 0, i32 1
// CHECK-NEXT: %toDestroy = load %swift.refcounted*, %swift.refcounted** %1, align 8
-// CHECK-NEXT: call void @swift_rt_swift_release(%swift.refcounted* %toDestroy) {{#[0-9]+}}
+// CHECK-NEXT: call void @swift_release(%swift.refcounted* %toDestroy) {{#[0-9]+}}
// CHECK-NEXT: ret void
sil public_external @invoke_nontrivial : $@convention(c) (@inout_aliasable @block_storage Builtin.NativeObject) -> ()
diff --git a/test/IRGen/objc_casts.sil b/test/IRGen/objc_casts.sil
index 20d38af..275a303 100644
--- a/test/IRGen/objc_casts.sil
+++ b/test/IRGen/objc_casts.sil
@@ -29,7 +29,7 @@
// TODO: is this really necessary? also, this really shouldn't use a direct reference
// CHECK-NEXT: [[T1:%.*]] = bitcast %objc_object* [[T0]] to i8*
// CHECK-NEXT: [[T2a:%.*]] = load %objc_class*, %objc_class** @"OBJC_CLASS_REF_$_Foo"
-// CHECK-NEXT: [[T2:%.*]] = call %objc_class* @swift_rt_swift_getInitializedObjCClass(%objc_class* [[T2a]])
+// CHECK-NEXT: [[T2:%.*]] = call %objc_class* @swift_getInitializedObjCClass(%objc_class* [[T2a]])
// CHECK-NEXT: [[T3:%.*]] = bitcast %objc_class* [[T2]] to i8*
// CHECK-NEXT: call i8* @swift_dynamicCastObjCClassUnconditional(i8* [[T1]], i8* [[T3]])
sil hidden @metatype_to_objc_class : $@convention(thin) <T> (@thick T.Type) -> () {
@@ -45,7 +45,7 @@
// TODO: is this really necessary? also, this really shouldn't use a direct reference
// CHECK-NEXT: [[T1:%.*]] = bitcast %objc_object* [[T0]] to i8*
// CHECK-NEXT: [[T2a:%.*]] = load %objc_class*, %objc_class** @"OBJC_CLASS_REF_$_Foo"
-// CHECK-NEXT: [[T2:%.*]] = call %objc_class* @swift_rt_swift_getInitializedObjCClass(%objc_class* [[T2a]])
+// CHECK-NEXT: [[T2:%.*]] = call %objc_class* @swift_getInitializedObjCClass(%objc_class* [[T2a]])
// CHECK-NEXT: [[T3:%.*]] = bitcast %objc_class* [[T2]] to i8*
// CHECK-NEXT: call i8* @swift_dynamicCastObjCClassUnconditional(i8* [[T1]], i8* [[T3]])
sil hidden @opt_metatype_to_objc_class : $@convention(thin) <T> (Optional<@thick T.Type>) -> () {
diff --git a/test/IRGen/objc_class_export.swift b/test/IRGen/objc_class_export.swift
index 3c0ae44..93b7b19 100644
--- a/test/IRGen/objc_class_export.swift
+++ b/test/IRGen/objc_class_export.swift
@@ -5,15 +5,15 @@
// REQUIRES: CPU=x86_64
// REQUIRES: objc_interop
-// CHECK: %swift.refcounted = type
-// CHECK: [[HOOZIT:%T17objc_class_export6HoozitC]] = type <{ [[REF:%swift.refcounted]] }>
-// CHECK: [[FOO:%T17objc_class_export3FooC]] = type <{ [[REF]], %TSi }>
-// CHECK: [[INT:%TSi]] = type <{ i64 }>
-// CHECK: [[DOUBLE:%TSd]] = type <{ double }>
-// CHECK: [[NSRECT:%TSo6NSRectV]] = type <{ %TSo7NSPointV, %TSo6NSSizeV }>
-// CHECK: [[NSPOINT:%TSo7NSPointV]] = type <{ %TSd, %TSd }>
-// CHECK: [[NSSIZE:%TSo6NSSizeV]] = type <{ %TSd, %TSd }>
-// CHECK: [[OBJC:%objc_object]] = type opaque
+// CHECK-DAG: %swift.refcounted = type
+// CHECK-DAG: [[HOOZIT:%T17objc_class_export6HoozitC]] = type <{ [[REF:%swift.refcounted]] }>
+// CHECK-DAG: [[FOO:%T17objc_class_export3FooC]] = type <{ [[REF]], %TSi }>
+// CHECK-DAG: [[INT:%TSi]] = type <{ i64 }>
+// CHECK-DAG: [[DOUBLE:%TSd]] = type <{ double }>
+// CHECK-DAG: [[NSRECT:%TSo6NSRectV]] = type <{ %TSo7NSPointV, %TSo6NSSizeV }>
+// CHECK-DAG: [[NSPOINT:%TSo7NSPointV]] = type <{ %TSd, %TSd }>
+// CHECK-DAG: [[NSSIZE:%TSo6NSSizeV]] = type <{ %TSd, %TSd }>
+// CHECK-DAG: [[OBJC:%objc_object]] = type opaque
// CHECK: @"OBJC_METACLASS_$__TtC17objc_class_export3Foo" = hidden global %objc_class {
// CHECK: %objc_class* @"OBJC_METACLASS_$__TtCs12_SwiftObject",
diff --git a/test/IRGen/objc_dealloc.sil b/test/IRGen/objc_dealloc.sil
index b8156bf..f920ce5 100644
--- a/test/IRGen/objc_dealloc.sil
+++ b/test/IRGen/objc_dealloc.sil
@@ -91,7 +91,7 @@
// CHECK-NEXT: [[IVAR_ADDR:%[a-zA-Z0-9]+]] = getelementptr inbounds i8, i8* {{.*}}, i64 [[XOFFSET]]
// CHECK-NEXT: [[XADDR:%[.a-zA-Z0-9]+]] = bitcast i8* [[IVAR_ADDR]] to %T12objc_dealloc1XC**
// CHECK-NEXT: [[X:%[a-zA-Z0-9]+]] = load %T12objc_dealloc1XC*, %T12objc_dealloc1XC** [[XADDR]], align 8
- // CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_rt_swift_release to void (%T12objc_dealloc1XC*)*)(%T12objc_dealloc1XC* [[X]])
+ // CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T12objc_dealloc1XC*)*)(%T12objc_dealloc1XC* [[X]])
%3 = begin_borrow %0 : $SwiftGizmo
%4 = ref_element_addr %3 : $SwiftGizmo, #SwiftGizmo.x // user: %4
destroy_addr %4 : $*X // id: %4
diff --git a/test/IRGen/objc_generic_class_metadata.sil b/test/IRGen/objc_generic_class_metadata.sil
index 3409af7..2f4a3b3 100644
--- a/test/IRGen/objc_generic_class_metadata.sil
+++ b/test/IRGen/objc_generic_class_metadata.sil
@@ -39,7 +39,7 @@
apply %z<GenericClass<NSObject>>(%b) : $@convention(thin) <T> (@thick T.Type) -> ()
// CHECK: [[T0:%.*]] = load %objc_class*, %objc_class** @"OBJC_CLASS_REF_$_GenericClass",
- // CHECK: [[OBJC_CLASS:%.*]] = call %objc_class* @swift_rt_swift_getInitializedObjCClass(%objc_class* [[T0]])
+ // CHECK: [[OBJC_CLASS:%.*]] = call %objc_class* @swift_getInitializedObjCClass(%objc_class* [[T0]])
// CHECK: call swiftcc void @objc_class_sink(%objc_class* [[OBJC_CLASS]], %swift.type* [[METADATA]])
%c = metatype $@objc_metatype GenericClass<NSString>.Type
apply %y<GenericClass<NSString>>(%c) : $@convention(thin) <T: AnyObject> (@objc_metatype T.Type) -> ()
@@ -78,7 +78,7 @@
// CHECK-LABEL: define linkonce_odr hidden %swift.type* @"$SSo12GenericClassCMa"()
// CHECK: [[T0:%.*]] = load %objc_class*, %objc_class** @"OBJC_CLASS_REF_$_GenericClass",
-// CHECK: call %objc_class* @swift_rt_swift_getInitializedObjCClass(%objc_class* [[T0]])
+// CHECK: call %objc_class* @swift_getInitializedObjCClass(%objc_class* [[T0]])
// CHECK-LABEL: define linkonce_odr hidden %swift.type* @"$SSaySo12GenericClassC_SitGMa"()
// CHECK: [[TUPLE:%.*]] = call %swift.type* @"$SSo12GenericClassC_SitMa"()
diff --git a/test/IRGen/objc_types_as_member.sil b/test/IRGen/objc_types_as_member.sil
index 4dae304..af2471c 100644
--- a/test/IRGen/objc_types_as_member.sil
+++ b/test/IRGen/objc_types_as_member.sil
@@ -22,6 +22,6 @@
}
// CHECK-LABEL: define {{.*}}%swift.type* @"$SSo9OuterTypeCMa"()
-// CHECK: [[TMP:%.*]] = call %objc_class* @swift_rt_swift_getInitializedObjCClass(
+// CHECK: [[TMP:%.*]] = call %objc_class* @swift_getInitializedObjCClass(
// CHECK: call %swift.type* @swift_getObjCClassMetadata(%objc_class* [[TMP]])
// CHECK: ret
diff --git a/test/IRGen/partial_apply.sil b/test/IRGen/partial_apply.sil
index d5d4fcb..151ebf4 100644
--- a/test/IRGen/partial_apply.sil
+++ b/test/IRGen/partial_apply.sil
@@ -104,7 +104,7 @@
// CHECK-NOT: release
// CHECK: [[RESULT:%.*]] = call swiftcc i64 @indirect_guaranteed_captured_class_param(i64 %0, %T13partial_apply10SwiftClassC** noalias nocapture dereferenceable({{.*}}) [[X_CAST]]
// CHECK-NOT: retain
-// CHECK: call void @swift_rt_swift_release(%swift.refcounted* %1)
+// CHECK: call void @swift_release(%swift.refcounted* %1)
// CHECK: ret i64 [[RESULT]]
sil @partial_apply_indirect_guaranteed_class_param : $@convention(thin) (@in SwiftClass) -> @callee_owned (Int) -> Int {
@@ -153,7 +153,7 @@
sil public_external @guaranteed_captured_class_pair_param : $@convention(thin) (Int, @guaranteed SwiftClassPair) -> Int
// CHECK-LABEL: define{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @partial_apply_guaranteed_class_pair_param(%T13partial_apply10SwiftClassC*, %T13partial_apply10SwiftClassC*)
-// CHECK: [[CONTEXT_OBJ:%.*]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject
+// CHECK: [[CONTEXT_OBJ:%.*]] = call noalias %swift.refcounted* @swift_allocObject
// CHECK: [[PAIR_ADDR:%.*]] = getelementptr
// CHECK-NEXT: [[X_ADDR:%.*]] = getelementptr inbounds %T13partial_apply14SwiftClassPairV, %T13partial_apply14SwiftClassPairV* [[PAIR_ADDR]], i32 0, i32 0
// CHECK-NEXT: store %T13partial_apply10SwiftClassC* %0, %T13partial_apply10SwiftClassC** [[X_ADDR]], align
@@ -184,7 +184,7 @@
sil public_external @indirect_guaranteed_captured_class_pair_param : $@convention(thin) (Int, @in_guaranteed SwiftClassPair) -> Int
// CHECK-LABEL: define{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @partial_apply_indirect_guaranteed_class_pair_param(%T13partial_apply14SwiftClassPairV* noalias nocapture dereferenceable({{.*}}))
-// CHECK: [[CONTEXT_OBJ:%.*]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject
+// CHECK: [[CONTEXT_OBJ:%.*]] = call noalias %swift.refcounted* @swift_allocObject
// CHECK-NOT: {{retain|release}}
// CHECK: [[T0:%.*]] = insertvalue {{.*}} [[PARTIAL_APPLY_FORWARDER:@"\$S[A-Za-z0-9_]+TA"]] {{.*}} [[CONTEXT_OBJ]]
// CHECK: ret {{.*}} [[T0]]
@@ -207,7 +207,7 @@
sil public_external @indirect_consumed_captured_class_pair_param : $@convention(thin) (Int, @in SwiftClassPair) -> Int
// CHECK-LABEL: define{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @partial_apply_indirect_consumed_class_pair_param(%T13partial_apply14SwiftClassPairV* noalias nocapture dereferenceable({{.*}}))
-// CHECK: [[CONTEXT_OBJ:%.*]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject
+// CHECK: [[CONTEXT_OBJ:%.*]] = call noalias %swift.refcounted* @swift_allocObject
// CHECK-NOT: {{retain|release}}
// CHECK: [[T0:%.*]] = insertvalue {{.*}} [[PARTIAL_APPLY_FORWARDER:@"\$S[A-Za-z0-9_]+TA"]] {{.*}} [[CONTEXT_OBJ]]
// CHECK: ret {{.*}} [[T0]]
@@ -267,7 +267,7 @@
// CHECK-32: [[TOTAL_ALIGN:%.*]] = or [[WORD]] [[TOTAL_ALIGN_1]], 3
// -- Allocate using the total size and alignment.
-// CHECK: [[BOX:%.*]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* {{.*}}, [[WORD]] [[TOTAL_SIZE]], [[WORD]] [[TOTAL_ALIGN]])
+// CHECK: [[BOX:%.*]] = call noalias %swift.refcounted* @swift_allocObject(%swift.type* {{.*}}, [[WORD]] [[TOTAL_SIZE]], [[WORD]] [[TOTAL_ALIGN]])
// CHECK: [[BOX_DATA:%.*]] = bitcast %swift.refcounted* [[BOX]]
// -- metadata
// CHECK: getelementptr inbounds {{.*}} [[BOX_DATA]], i32 0, i32 1
@@ -387,7 +387,7 @@
return %result : $()
}
// CHECK-LABEL: define{{( protected)?}} swiftcc void @partial_apply_complex_generic_function(i64, %swift.type* %T, i8** %T.P2, i8** %T.Y.P2)
-// CHECK: [[T0:%.*]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* {{.*}}, i64 48, i64 7)
+// CHECK: [[T0:%.*]] = call noalias %swift.refcounted* @swift_allocObject(%swift.type* {{.*}}, i64 48, i64 7)
// CHECK-NEXT: [[T1:%.*]] = bitcast %swift.refcounted* [[T0]] to <{ %swift.refcounted, [24 x i8], %TSi }>*
// CHECK-NEXT: [[T2:%.*]] = getelementptr inbounds <{ %swift.refcounted, [24 x i8], %TSi }>, <{ %swift.refcounted, [24 x i8], %TSi }>* [[T1]], i32 0, i32 1
// CHECK-NEXT: [[BUFFER:%.*]] = bitcast [24 x i8]* [[T2]] to %swift.type**
diff --git a/test/IRGen/partial_apply_forwarder.sil b/test/IRGen/partial_apply_forwarder.sil
index 0a2982e..043bf64 100644
--- a/test/IRGen/partial_apply_forwarder.sil
+++ b/test/IRGen/partial_apply_forwarder.sil
@@ -80,7 +80,7 @@
// CHECK: entry:
// CHECK: [[BPTYPE:%.*]] = call %swift.type* @"$S23partial_apply_forwarder12BaseProducerVMa"(%swift.type* %"\CF\84_0_1")
// CHECK: [[WEAKBOXTYPE:%.*]] = call %swift.type* @"$S23partial_apply_forwarder7WeakBoxCMa"(%swift.type* [[BPTYPE]])
-// CHECK: [[OBJ:%.*]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* [[WEAKBOXTYPE]]
+// CHECK: [[OBJ:%.*]] = call noalias %swift.refcounted* @swift_allocObject(%swift.type* [[WEAKBOXTYPE]]
// CHECK: [[WB:%.*]] = bitcast %swift.refcounted* [[OBJ]] to %T23partial_apply_forwarder7WeakBoxC*
// CHECK: [[REF:%.*]] = bitcast %T23partial_apply_forwarder7WeakBoxC* [[WB]] to %swift.refcounted*
// CHECK: [[CLOSURE:%.*]] = insertvalue { i8*, %swift.refcounted* } { i8* bitcast (void (%swift.refcounted*)* @"$S7takingQTA" to i8*), %swift.refcounted* undef }, %swift.refcounted* [[REF]], 1
@@ -108,7 +108,7 @@
}
// CHECK-LABEL: define{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @bind_polymorphic_param_from_context_2(%swift.opaque* noalias nocapture, %swift.type* %"\CF\84_0_1")
-// CHECK: [[OBJ:%.*]] = call {{.*}} @swift_rt_swift_allocObject
+// CHECK: [[OBJ:%.*]] = call {{.*}} @swift_allocObject
// CHECK: [[WB:%.*]] = bitcast %swift.refcounted* [[OBJ]]
// CHECK: [[REF:%.*]] = bitcast {{.*}}* [[WB]] to %swift.refcounted*
// CHECK: [[CLOSURE:%.*]] = insertvalue { i8*, %swift.refcounted* } { i8* bitcast (void (%swift.refcounted*)* @"$S15takingQAndEmptyTA" to i8*), %swift.refcounted* undef }, %swift.refcounted* [[REF]], 1
@@ -122,7 +122,7 @@
}
// CHECK-LABEL: define{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @bind_polymorphic_param_from_context_3(%swift.opaque* noalias nocapture, %swift.type* %"\CF\84_0_1")
-// CHECK: [[OBJ:%.*]] = call {{.*}} @swift_rt_swift_allocObject
+// CHECK: [[OBJ:%.*]] = call {{.*}} @swift_allocObject
// CHECK: [[WB:%.*]] = bitcast %swift.refcounted* [[OBJ]]
// CHECK: [[REF:%.*]] = bitcast {{.*}}* [[WB]] to %swift.refcounted*
// CHECK: [[CLOSURE:%.*]] = insertvalue { i8*, %swift.refcounted* } { i8* bitcast (void (%swift.refcounted*)* @"$S15takingEmptyAndQTA" to i8*), %swift.refcounted* undef }, %swift.refcounted* [[REF]], 1
@@ -140,7 +140,7 @@
// CHECK: entry:
// CHECK: [[BPTY:%.*]] = call %swift.type* @"$S23partial_apply_forwarder12BaseProducerVMa"(%swift.type* %"\CF\84_0_1")
// CHECK: [[WBTY:%.*]] = call %swift.type* @"$S23partial_apply_forwarder7WeakBoxCMa"(%swift.type* [[BPTY]]
-// CHECK: call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* [[WBTY]]
+// CHECK: call noalias %swift.refcounted* @swift_allocObject(%swift.type* [[WBTY]]
// CHECK: ret void
// CHECK-LABEL: define internal swiftcc void @"$S7takingQTA.2"(%T23partial_apply_forwarder7WeakBoxC*, %swift.refcounted* swiftself)
@@ -174,9 +174,9 @@
// CHECK: entry:
// CHECK: [[BPTY:%.*]] = call %swift.type* @"$S23partial_apply_forwarder12BaseProducerVMa"(%swift.type* %"\CF\84_0_1")
// CHECK: [[WBTY:%.*]] = call %swift.type* @"$S23partial_apply_forwarder7WeakBoxCMa"(%swift.type* [[BPTY]]
-// CHECK: [[WBREF:%.*]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* [[WBTY]]
+// CHECK: [[WBREF:%.*]] = call noalias %swift.refcounted* @swift_allocObject(%swift.type* [[WBTY]]
// CHECK: [[WB:%.*]] = bitcast %swift.refcounted* [[WBREF]] to %T23partial_apply_forwarder7WeakBoxC*
-// CHECK: [[CONTEXT0:%.*]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject
+// CHECK: [[CONTEXT0:%.*]] = call noalias %swift.refcounted* @swift_allocObject
// CHECK: [[CONTEXT:%.*]] = bitcast %swift.refcounted* [[CONTEXT0]] to <{ %swift.refcounted,{{.*}} %T23partial_apply_forwarder1SV, %T23partial_apply_forwarder7WeakBoxC* }>*
// CHECK: [[SADDR:%.*]] = getelementptr inbounds <{ %swift.refcounted,{{.*}} %T23partial_apply_forwarder1SV, %T23partial_apply_forwarder7WeakBoxC* }>, <{ %swift.refcounted,{{.*}} %T23partial_apply_forwarder1SV, %T23partial_apply_forwarder7WeakBoxC* }>* [[CONTEXT]], i32 0, i32 {{(1|2)}}
// CHECK: [[XADDR:%.*]] = getelementptr inbounds %T23partial_apply_forwarder1SV, %T23partial_apply_forwarder1SV* [[SADDR]], i32 0, i32 0
@@ -195,11 +195,11 @@
// CHECK: [[WBADDR:%.*]] = getelementptr inbounds <{ %swift.refcounted,{{.*}} %T23partial_apply_forwarder1SV, %T23partial_apply_forwarder7WeakBoxC* }>, <{ %swift.refcounted,{{.*}} %T23partial_apply_forwarder1SV, %T23partial_apply_forwarder7WeakBoxC* }>* [[CONTEXT]], i32 0, i32 {{(2|3)}}
// CHECK: [[WB:%.*]] = load %T23partial_apply_forwarder7WeakBoxC*, %T23partial_apply_forwarder7WeakBoxC** [[WBADDR]]
// CHECK: [[WBREF:%.*]] = bitcast %T23partial_apply_forwarder7WeakBoxC* [[WB]] to %swift.refcounted*
-// CHECK: call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* returned [[WBREF]])
+// CHECK: call %swift.refcounted* @swift_retain(%swift.refcounted* returned [[WBREF]])
// CHECK: [[TYADDR:%.*]] = getelementptr inbounds %T23partial_apply_forwarder7WeakBoxC, %T23partial_apply_forwarder7WeakBoxC* [[WB]], i32 0, i32 0, i32 0
// CHECK: [[TY:%.*]] = load %swift.type*, %swift.type** [[TYADDR]]
// CHECK: %.asUnsubstituted = bitcast %T23partial_apply_forwarder7WeakBoxC* [[WB]] to %T23partial_apply_forwarder7WeakBoxC.1*
-// CHECK: call void @swift_rt_swift_release(%swift.refcounted* %0)
+// CHECK: call void @swift_release(%swift.refcounted* %0)
// CHECK: [[GENPARAMSADDR:%.*]] = bitcast %swift.type* [[TY]] to %swift.type**
// CHECK: [[GENPARAMADDR:%.*]] = getelementptr inbounds %swift.type*, %swift.type** [[GENPARAMSADDR]], {{(i64 10|i32 13)}}
// CHECK: %"BaseProducer<\CF\84_0_1>" = load %swift.type*, %swift.type** [[GENPARAMADDR]]
diff --git a/test/IRGen/partial_apply_objc.sil b/test/IRGen/partial_apply_objc.sil
index fe10ad6..7be814a 100644
--- a/test/IRGen/partial_apply_objc.sil
+++ b/test/IRGen/partial_apply_objc.sil
@@ -51,7 +51,7 @@
// CHECK-LABEL: define{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @indirect_partial_apply(i8*, %swift.refcounted*, i64) {{.*}} {
// CHECK: entry:
// CHECK: [[T0:%.*]] = bitcast i8* %0 to void (i64, %swift.refcounted*)*
-// CHECK: [[OBJ:%.*]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* getelementptr inbounds (%swift.full_boxmetadata, %swift.full_boxmetadata* @metadata, i32 0, i32 2), i64 40, i64 7)
+// CHECK: [[OBJ:%.*]] = call noalias %swift.refcounted* @swift_allocObject(%swift.type* getelementptr inbounds (%swift.full_boxmetadata, %swift.full_boxmetadata* @metadata, i32 0, i32 2), i64 40, i64 7)
// CHECK: [[DATA_ADDR:%.*]] = bitcast %swift.refcounted* [[OBJ]] to [[DATA_TYPE:<{ %swift.refcounted, i64, %swift.refcounted\*, i8\* }>]]*
// CHECK: [[X_ADDR:%.*]] = getelementptr inbounds [[DATA_TYPE]], [[DATA_TYPE]]* [[DATA_ADDR]], i32 0, i32 1
// CHECK: store i64 %2, i64* [[X_ADDR]], align 8
@@ -85,7 +85,7 @@
// CHECK-LABEL: define{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @objc_partial_apply(%T18partial_apply_objc9ObjCClassC*) {{.*}} {
// CHECK: entry:
-// CHECK: [[OBJ:%.*]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* getelementptr inbounds (%swift.full_boxmetadata, %swift.full_boxmetadata* @metadata.2, i32 0, i32 2), i64 24, i64 7)
+// CHECK: [[OBJ:%.*]] = call noalias %swift.refcounted* @swift_allocObject(%swift.type* getelementptr inbounds (%swift.full_boxmetadata, %swift.full_boxmetadata* @metadata.2, i32 0, i32 2), i64 24, i64 7)
// CHECK: [[DATA_ADDR:%.*]] = bitcast %swift.refcounted* [[OBJ]] to [[DATA_TYPE:<{ %swift.refcounted, %T18partial_apply_objc9ObjCClassC\* }>]]*
// CHECK: [[X_ADDR:%.*]] = getelementptr inbounds [[DATA_TYPE]], [[DATA_TYPE]]* [[DATA_ADDR]], i32 0, i32 1
// CHECK: store %T18partial_apply_objc9ObjCClassC* %0, %T18partial_apply_objc9ObjCClassC** [[X_ADDR]], align 8
@@ -116,7 +116,7 @@
}
// CHECK-LABEL: define{{.*}} { i8*, %swift.refcounted* } @objc_partial_apply_indirect_sil_argument(%T18partial_apply_objc9ObjCClassC*) {{.*}}
-// CHECK: [[CTX:%.*]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject
+// CHECK: [[CTX:%.*]] = call noalias %swift.refcounted* @swift_allocObject
// CHECK: [[CTX_ADDR:%.*]] = bitcast %swift.refcounted* [[CTX]] to [[CTXTYPE:<{ %swift.refcounted, %T18partial_apply_objc9ObjCClassC\* }>]]*
// CHECK: [[SELF_ADDR:%.*]] = getelementptr inbounds [[CTXTYPE]], [[CTXTYPE]]* [[CTX_ADDR]], i32 0, i32 1
// CHECK: store %T18partial_apply_objc9ObjCClassC* %0, %T18partial_apply_objc9ObjCClassC** [[SELF_ADDR]]
@@ -148,7 +148,7 @@
// CHECK: [[I8PTRSELF:%.*]] = bitcast %T18partial_apply_objc9ObjCClassC* [[SELF]] to [[OPAQUE4:%.*]]*
// CHECK: call [[OPAQUE3:%.*]]* bitcast (void ()* @objc_msgSend to [[OPAQUE3]]* ([[OPAQUE4:%.*]]*, i8*)*)([[OPAQUE4]]* [[I8PTRSELF]], i8* [[CMD]])
// CHECK-NOT: release
-// CHECK: call void @swift_rt_swift_release(%swift.refcounted* %0)
+// CHECK: call void @swift_release(%swift.refcounted* %0)
// CHECK-NOT: release
// CHECK: ret void
// CHECK: }
@@ -191,7 +191,7 @@
sil @partially_applyable_to_pure_objc : $@convention(thin) Gizmo -> ()
// CHECK: define{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @partial_apply_pure_objc
-// CHECK: @swift_rt_swift_allocObject
+// CHECK: @swift_allocObject
sil @partial_apply_pure_objc : $@convention(thin) Gizmo -> @callee_owned () -> () {
entry(%c : $Gizmo):
%f = function_ref @partially_applyable_to_pure_objc : $@convention(thin) Gizmo -> ()
@@ -227,7 +227,7 @@
}
// CHECK-LABEL: define {{.*}}@objc_partial_apply_callee_guaranteed
-// CHECK: [[CONTEXT:%.*]] = call {{.*}}@swift_rt_swift_allocObject
+// CHECK: [[CONTEXT:%.*]] = call {{.*}}@swift_allocObject
// CHECK: store
// CHECK: [[CLOSURE:%.*]] = insertvalue {{.*}}@"$STa.20"{{.*}}, {{.*}}[[CONTEXT]], 1
// CHECK: ret {{.*}}[[CLOSURE]]
@@ -250,7 +250,7 @@
// CHECK: }
// CHECK-LABEL: define {{.*}}@objc_partial_apply_2_callee_guaranteed
-// CHECK: [[CONTEXT:%.*]] = call {{.*}}@swift_rt_swift_allocObject
+// CHECK: [[CONTEXT:%.*]] = call {{.*}}@swift_allocObject
// CHECK: store
// CHECK: [[CLOSURE:%.*]] = insertvalue {{.*}}@"$STa.23"{{.*}}, {{.*}}[[CONTEXT]], 1
// CHECK: ret {{.*}}[[CLOSURE]]
diff --git a/test/IRGen/protocol_metadata.swift b/test/IRGen/protocol_metadata.swift
index 184db19..106d0ff 100644
--- a/test/IRGen/protocol_metadata.swift
+++ b/test/IRGen/protocol_metadata.swift
@@ -120,12 +120,12 @@
abc: A & B & C,
abco: A & B & C & O) {
// CHECK: store %swift.protocol* @"$S17protocol_metadata1AMp"
- // CHECK: call %swift.type* @swift_rt_swift_getExistentialTypeMetadata(i1 true, %swift.type* null, i64 1, %swift.protocol** {{%.*}})
+ // CHECK: call %swift.type* @swift_getExistentialTypeMetadata(i1 true, %swift.type* null, i64 1, %swift.protocol** {{%.*}})
reify_metadata(a)
// CHECK: store %swift.protocol* @"$S17protocol_metadata1AMp"
// CHECK: store %swift.protocol* @"$S17protocol_metadata1BMp"
// CHECK: store %swift.protocol* @"$S17protocol_metadata1CMp"
- // CHECK: call %swift.type* @swift_rt_swift_getExistentialTypeMetadata(i1 false, %swift.type* null, i64 3, %swift.protocol** {{%.*}})
+ // CHECK: call %swift.type* @swift_getExistentialTypeMetadata(i1 false, %swift.type* null, i64 3, %swift.protocol** {{%.*}})
reify_metadata(abc)
// CHECK: store %swift.protocol* @"$S17protocol_metadata1AMp"
// CHECK: store %swift.protocol* @"$S17protocol_metadata1BMp"
@@ -133,7 +133,7 @@
// CHECK: [[O_REF:%.*]] = load i8*, i8** @"\01l_OBJC_PROTOCOL_REFERENCE_$__TtP17protocol_metadata1O_"
// CHECK: [[O_REF_BITCAST:%.*]] = bitcast i8* [[O_REF]] to %swift.protocol*
// CHECK: store %swift.protocol* [[O_REF_BITCAST]]
- // CHECK: call %swift.type* @swift_rt_swift_getExistentialTypeMetadata(i1 false, %swift.type* null, i64 4, %swift.protocol** {{%.*}})
+ // CHECK: call %swift.type* @swift_getExistentialTypeMetadata(i1 false, %swift.type* null, i64 4, %swift.protocol** {{%.*}})
reify_metadata(abco)
}
diff --git a/test/IRGen/protocol_resilience.sil b/test/IRGen/protocol_resilience.sil
index ab37060..fe4b5dc 100644
--- a/test/IRGen/protocol_resilience.sil
+++ b/test/IRGen/protocol_resilience.sil
@@ -101,7 +101,7 @@
// implementation
// CHECK-NEXT: [[WTABLE:%.*]] = bitcast i8** %SelfWitnessTable to i8*
- // CHECK-NEXT: [[CONTEXT:%.*]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject({{.*}})
+ // CHECK-NEXT: [[CONTEXT:%.*]] = call noalias %swift.refcounted* @swift_allocObject({{.*}})
// CHECK-NEXT: [[LAYOUT:%.*]] = bitcast %swift.refcounted* [[CONTEXT]] to <{ %swift.refcounted, [{{4|8}} x i8], i8* }>*
// CHECK: [[WTABLE_ADDR:%.*]] = getelementptr inbounds <{ %swift.refcounted, [{{4|8}} x i8], i8* }>, <{ %swift.refcounted, [{{4|8}} x i8], i8* }>* [[LAYOUT]], i32 0, i32 2
// CHECK-NEXT: store i8* [[WTABLE]], i8** [[WTABLE_ADDR]]
@@ -141,7 +141,7 @@
// implementation
// CHECK-NEXT: [[WTABLE:%.*]] = bitcast i8** %SelfWitnessTable to i8*
- // CHECK-NEXT: [[CONTEXT:%.*]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject({{.*}})
+ // CHECK-NEXT: [[CONTEXT:%.*]] = call noalias %swift.refcounted* @swift_allocObject({{.*}})
// CHECK-NEXT: [[LAYOUT:%.*]] = bitcast %swift.refcounted* [[CONTEXT]] to <{ %swift.refcounted, [{{4|8}} x i8], i8* }>*
// CHECK: [[WTABLE_ADDR:%.*]] = getelementptr inbounds <{ %swift.refcounted, [{{4|8}} x i8], i8* }>, <{ %swift.refcounted, [{{4|8}} x i8], i8* }>* [[LAYOUT]], i32 0, i32 2
// CHECK-NEXT: store i8* [[WTABLE]], i8** [[WTABLE_ADDR]]
@@ -221,7 +221,7 @@
// Make sure we can partially apply direct references to default implementations
- // CHECK-NEXT: [[CONTEXT:%.*]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject({{.*}})
+ // CHECK-NEXT: [[CONTEXT:%.*]] = call noalias %swift.refcounted* @swift_allocObject({{.*}})
// CHECK-NEXT: [[LAYOUT:%.*]] = bitcast %swift.refcounted* [[CONTEXT]] to <{ %swift.refcounted, i8* }>*
// CHECK-NEXT: [[WTABLE:%.*]] = getelementptr inbounds <{ %swift.refcounted, i8* }>, <{ %swift.refcounted, i8* }>* [[LAYOUT]], i32 0, i32 1
// CHECK-NEXT: store i8* bitcast ([9 x i8*]* @"$S19protocol_resilience16ConformingStructVAA17ResilientProtocolAAWP" to i8*), i8** [[WTABLE]]
@@ -300,7 +300,7 @@
// CHECK-NEXT: [[COUNT_PTR:%.*]] = getelementptr inbounds %swift.witness_table_slice, %swift.witness_table_slice* %conditional.tables, i32 0, i32 1
// CHECK-NEXT: store [[WORD:i(32|64)]] 0, [[WORD:i(32|64)]]* [[COUNT_PTR]]
// CHECK-NEXT: [[INSTANTIATION_ARGS:%.*]] = bitcast %swift.witness_table_slice* %conditional.tables to i8**
-// CHECK-NEXT: [[WTABLE:%.*]] = call i8** @swift_rt_swift_getGenericWitnessTable(%swift.generic_witness_table_cache* @"$S19protocol_resilience23ResilientConformingTypeV010resilient_A005OtherC8ProtocolAAWG", %swift.type* null, i8** [[INSTANTIATION_ARGS]])
+// CHECK-NEXT: [[WTABLE:%.*]] = call i8** @swift_getGenericWitnessTable(%swift.generic_witness_table_cache* @"$S19protocol_resilience23ResilientConformingTypeV010resilient_A005OtherC8ProtocolAAWG", %swift.type* null, i8** [[INSTANTIATION_ARGS]])
// CHECK-NEXT: ret i8** [[WTABLE]]
diff --git a/test/IRGen/runtime_calling_conventions.swift b/test/IRGen/runtime_calling_conventions.swift
index 16d3727..e7d0d97 100644
--- a/test/IRGen/runtime_calling_conventions.swift
+++ b/test/IRGen/runtime_calling_conventions.swift
@@ -2,35 +2,17 @@
// RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -parse-as-library -O -emit-ir %s | %FileCheck --check-prefix=OPT-CHECK %s
// Test that runtime functions are invoked using the new calling convention.
-// Test that wrappers are used to invoked them.
-
-// TODO: Once the PreserveRegistersCC calling convention is enabled, check that it is really used.
public class C {
}
// CHECK-LABEL: define {{(protected )?}}swiftcc void @"$S27runtime_calling_conventions3fooyyAA1CCF"(%T27runtime_calling_conventions1CC*)
// Check that runtime functions use a proper calling convention.
-// CHECK: call void {{.*}} @swift_rt_swift_release
+// CHECK: call void {{.*}} @swift_release
// OPT-CHECK-LABEL: define {{(protected )?}}swiftcc void @"$S27runtime_calling_conventions3fooyyAA1CCF"(%T27runtime_calling_conventions1CC*)
// Check that runtime functions use a proper calling convention.
-// OPT-CHECK: tail call void @swift_rt_swift_release
+// OPT-CHECK: tail call void @swift_release
public func foo(_ c: C) {
}
-
-// Check that wrappers were generated, have a proper calling convention, linkage
-// and linkonce_odr flags.
-
-// CHECK: define linkonce_odr hidden void @swift_rt_swift_release(%swift.refcounted*) #[[ATTR_REF:[0-9]+]]
-// CHECK: load void (%swift.refcounted*)*, void (%swift.refcounted*)** @_swift_release
-// CHECK-NEXT: tail call void %load(%swift.refcounted* %0)
-// CHECK-NEXT: ret void
-// CHECK: attributes #[[ATTR_REF]] = { noinline nounwind }
-
-// OPT-CHECK: define linkonce_odr hidden void @swift_rt_swift_release(%swift.refcounted*) local_unnamed_addr #[[ATTR_REF:[0-9]+]]
-// OPT-CHECK: load void (%swift.refcounted*)*, void (%swift.refcounted*)** @_swift_release
-// OPT-CHECK-NEXT: tail call void %load(%swift.refcounted* %0)
-// OPT-CHECK-NEXT: ret void
-// OPT-CHECK: attributes #[[ATTR_REF]] = { noinline nounwind }
diff --git a/test/IRGen/sil_witness_methods.sil b/test/IRGen/sil_witness_methods.sil
index af78bd1..0e540d2 100644
--- a/test/IRGen/sil_witness_methods.sil
+++ b/test/IRGen/sil_witness_methods.sil
@@ -145,7 +145,7 @@
}
// CHECK-LABEL: define{{( protected)?}} swiftcc { i8*, %swift.refcounted* } @partial_apply_concrete_witness() {{.*}} {
-// CHECK: [[CONTEXT:%.*]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject({{.*}})
+// CHECK: [[CONTEXT:%.*]] = call noalias %swift.refcounted* @swift_allocObject({{.*}})
// CHECK: [[LAYOUT:%.*]] = bitcast %swift.refcounted* [[CONTEXT]] to <{ %swift.refcounted, i8* }>*
// CHECK: [[WTABLE:%.*]] = getelementptr inbounds <{ %swift.refcounted, i8* }>, <{ %swift.refcounted, i8* }>* [[LAYOUT]], i32 0, i32 1
// CHECK: store i8* null, i8** [[WTABLE]]
diff --git a/test/IRGen/subclass.swift b/test/IRGen/subclass.swift
index d77e58f..e91d242 100644
--- a/test/IRGen/subclass.swift
+++ b/test/IRGen/subclass.swift
@@ -3,13 +3,13 @@
// REQUIRES: CPU=x86_64
// REQUIRES: objc_interop
-// CHECK: %swift.refcounted = type {
-// CHECK: [[TYPE:%swift.type]] = type
-// CHECK: [[OBJC_CLASS:%objc_class]] = type {
-// CHECK: [[OPAQUE:%swift.opaque]] = type
-// CHECK: [[A:%T8subclass1AC]] = type <{ [[REF:%swift.refcounted]], %TSi, %TSi }>
-// CHECK: [[INT:%TSi]] = type <{ i64 }>
-// CHECK: [[B:%T8subclass1BC]] = type <{ [[REF]], [[INT]], [[INT]], [[INT]] }>
+// CHECK-DAG: %swift.refcounted = type {
+// CHECK-DAG: [[TYPE:%swift.type]] = type
+// CHECK-DAG: [[OBJC_CLASS:%objc_class]] = type {
+// CHECK-DAG: [[OPAQUE:%swift.opaque]] = type
+// CHECK-DAG: [[A:%T8subclass1AC]] = type <{ [[REF:%swift.refcounted]], %TSi, %TSi }>
+// CHECK-DAG: [[INT:%TSi]] = type <{ i64 }>
+// CHECK-DAG: [[B:%T8subclass1BC]] = type <{ [[REF]], [[INT]], [[INT]], [[INT]] }>
// CHECK: @_DATA__TtC8subclass1A = private constant {{.*\* } }}{
// CHECK: @"$S8subclass1ACMf" = internal global [[A_METADATA:<{.*i64 }>]] <{
diff --git a/test/IRGen/subclass_existentials.sil b/test/IRGen/subclass_existentials.sil
index 0099c87..7df7c0b 100644
--- a/test/IRGen/subclass_existentials.sil
+++ b/test/IRGen/subclass_existentials.sil
@@ -22,8 +22,8 @@
// CHECK-native-LABEL: define{{( protected)?}} swiftcc void @checkRefcounting(%T21subclass_existentials1CC*, i8**, %swift.refcounted*, i8**)
// CHECK-NEXT: entry:
// CHECK-objc-NEXT: call void @swift_unknownRelease(%objc_object* %2)
-// CHECK-native-NEXT: call void @swift_rt_swift_release(%swift.refcounted* %2)
-// CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_rt_swift_release to void (%T21subclass_existentials1CC*)*)(%T21subclass_existentials1CC* %0)
+// CHECK-native-NEXT: call void @swift_release(%swift.refcounted* %2)
+// CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T21subclass_existentials1CC*)*)(%T21subclass_existentials1CC* %0)
// CHECK-NEXT: ret void
sil @checkRefcounting : $@convention(thin) (@owned C & P, @owned AnyObject & P) -> () {
@@ -53,7 +53,7 @@
// CHECK-NEXT: [[PROTOCOL:%.*]] = getelementptr inbounds %swift.protocol*, %swift.protocol** [[PROTOCOLS]], i32 0
// CHECK-NEXT: store %swift.protocol* @"$S21subclass_existentials1PMp", %swift.protocol** [[PROTOCOL]]
// CHECK-NEXT: [[SUPERCLASS:%.*]] = call %swift.type* @"$S21subclass_existentials1CCMa"()
-// CHECK-NEXT: [[METATYPE:%.*]] = call %swift.type* @swift_rt_swift_getExistentialTypeMetadata(i1 false, %swift.type* [[SUPERCLASS]], {{i32|i64}} 1, %swift.protocol** [[PROTOCOLS]])
+// CHECK-NEXT: [[METATYPE:%.*]] = call %swift.type* @swift_getExistentialTypeMetadata(i1 false, %swift.type* [[SUPERCLASS]], {{i32|i64}} 1, %swift.protocol** [[PROTOCOLS]])
// CHECK: ret
sil @checkMetadata : $@convention(thin) () -> () {
@@ -102,7 +102,7 @@
// CHECK-NEXT: [[WTABLE:%.*]] = extractvalue { i8*, i8** } [[RESULT]], 1
%2 = unconditional_checked_cast %0 : $C to $D & R
-// CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_rt_swift_release to void (%T21subclass_existentials1DC*)*)(%T21subclass_existentials1DC* [[VALUE]])
+// CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T21subclass_existentials1DC*)*)(%T21subclass_existentials1DC* [[VALUE]])
destroy_value %2 : $D & R
// CHECK-NEXT: [[VALUE:%.*]] = bitcast %T21subclass_existentials1CC* %1 to i8*
@@ -111,7 +111,7 @@
// CHECK-NEXT: [[VALUE:%.*]] = bitcast i8* [[RESULT]] to %T21subclass_existentials1DC*
%3 = unconditional_checked_cast %1 : $C & P to $D
-// CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_rt_swift_release to void (%T21subclass_existentials1DC*)*)(%T21subclass_existentials1DC* [[VALUE]])
+// CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T21subclass_existentials1DC*)*)(%T21subclass_existentials1DC* [[VALUE]])
destroy_value %3 : $D
// CHECK-NEXT: ret void
@@ -152,7 +152,7 @@
// CHECK-NEXT: [[WTABLE:%.*]] = extractvalue { i8*, i8** } [[RESULT]], 1
%2 = unconditional_checked_cast %0 : $C to $C & P
-// CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_rt_swift_release to void (%T21subclass_existentials1CC*)*)(%T21subclass_existentials1CC* [[VALUE]])
+// CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T21subclass_existentials1CC*)*)(%T21subclass_existentials1CC* [[VALUE]])
destroy_value %2 : $C & P
// CHECK-NEXT: ret void
diff --git a/test/IRGen/tail_alloc.sil b/test/IRGen/tail_alloc.sil
index f333d98..9f1996d 100644
--- a/test/IRGen/tail_alloc.sil
+++ b/test/IRGen/tail_alloc.sil
@@ -35,7 +35,7 @@
// CHECK-LABEL: define{{( protected)?}} {{.*}}* @alloc_on_heap
// CHECK: [[M:%[0-9]+]] = call %swift.type* @"$S{{[a-zA-Z0-9_]+}}Ma"()
-// CHECK-NEXT: [[O:%[0-9]+]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* [[M]], i64 28, i64 7)
+// CHECK-NEXT: [[O:%[0-9]+]] = call noalias %swift.refcounted* @swift_allocObject(%swift.type* [[M]], i64 28, i64 7)
// CHECK-NEXT: [[O2:%[0-9]+]] = bitcast %swift.refcounted* [[O]] to %[[C:.*TestClass.*]]*
// CHECK-NEXT: ret %[[C]]* [[O2]]
sil @alloc_on_heap : $@convention(thin) () -> @owned TestClass {
@@ -47,7 +47,7 @@
// CHECK-LABEL: define{{( protected)?}} {{.*}}* @alloc_3_on_heap
// CHECK: [[M:%[0-9]+]] = call %swift.type* @"$S{{[a-zA-Z0-9_]+}}CMa"()
-// CHECK-NEXT: [[O:%[0-9]+]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* [[M]], i64 40, i64 7)
+// CHECK-NEXT: [[O:%[0-9]+]] = call noalias %swift.refcounted* @swift_allocObject(%swift.type* [[M]], i64 40, i64 7)
// CHECK-NEXT: [[O2:%[0-9]+]] = bitcast %swift.refcounted* [[O]] to %[[C:.*TestClass.*]]*
// CHECK-NEXT: ret %[[C]]* [[O2]]
sil @alloc_3_on_heap : $@convention(thin) () -> @owned TestClass {
@@ -63,7 +63,7 @@
// CHECK: [[M:%[0-9]+]] = call %swift.type* @"$S{{[a-zA-Z0-9_]+}}Ma"()
// CHECK-NEXT: [[S:%[0-9]+]] = mul i64 4, %0
// CHECK-NEXT: [[A:%[0-9]+]] = add i64 20, [[S]]
-// CHECK-NEXT: [[O:%[0-9]+]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* [[M]], i64 [[A]], i64 7)
+// CHECK-NEXT: [[O:%[0-9]+]] = call noalias %swift.refcounted* @swift_allocObject(%swift.type* [[M]], i64 [[A]], i64 7)
// CHECK-NEXT: [[O2:%[0-9]+]] = bitcast %swift.refcounted* [[O]] to %[[C:.*TestClass.*]]*
// CHECK-NEXT: ret %[[C]]* [[O2]]
sil @alloc_non_const_count : $@convention(thin) (Builtin.Word) -> @owned TestClass {
@@ -80,7 +80,7 @@
// CHECK-NEXT: [[S4:%[0-9]+]] = and i64 [[S3]], -4
// CHECK-NEXT: [[S5:%[0-9]+]] = mul i64 4, %1
// CHECK-NEXT: [[S6:%[0-9]+]] = add i64 [[S4]], [[S5]]
-// CHECK-NEXT: [[O:%[0-9]+]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* [[M]], i64 [[S6]], i64 7)
+// CHECK-NEXT: [[O:%[0-9]+]] = call noalias %swift.refcounted* @swift_allocObject(%swift.type* [[M]], i64 [[S6]], i64 7)
// CHECK-NEXT: [[O2:%[0-9]+]] = bitcast %swift.refcounted* [[O]] to %[[C:.*TestClass.*]]*
// CHECK-NEXT: ret %[[C]]* [[O2]]
sil @alloc_2_non_const_count : $@convention(thin) (Builtin.Word, Builtin.Word) -> @owned TestClass {
@@ -95,7 +95,7 @@
// CHECK-NEXT: [[S3:%[0-9]+]] = and i64 [[S1]], [[S2]]
// CHECK-NEXT: [[S4:%[0-9]+]] = mul i64 %stride, %0
// CHECK-NEXT: [[S5:%[0-9]+]] = add i64 [[S3]], [[S4]]
-// CHECK: call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* %{{[0-9]+}}, i64 [[S5]], i64 7)
+// CHECK: call noalias %swift.refcounted* @swift_allocObject(%swift.type* %{{[0-9]+}}, i64 [[S5]], i64 7)
// CHECK: ret
sil @alloc_generic : $@convention(thin) <T> (Builtin.Word, @thick T.Type) -> @owned TestClass {
bb0(%0 : $Builtin.Word, %1 : $@thick T.Type):
@@ -113,7 +113,7 @@
// CHECK: [[ALIGN_TMP:%[0-9]+]] = add i64 [[SIZE64]], 3
// CHECK-NEXT: [[ALIGNED:%[0-9]+]] = and i64 [[ALIGN_TMP]], -4
// CHECK-NEXT: [[TOTAL_SIZE:%[0-9]+]] = add i64 [[ALIGNED]], 12
-// CHECK-NEXT: [[O:%[0-9]+]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* %0, i64 [[TOTAL_SIZE]], i64 {{.*}})
+// CHECK-NEXT: [[O:%[0-9]+]] = call noalias %swift.refcounted* @swift_allocObject(%swift.type* %0, i64 [[TOTAL_SIZE]], i64 {{.*}})
// CHECK-NEXT: [[O2:%[0-9]+]] = bitcast %swift.refcounted* [[O]] to %{{.*TestClassC}}*
// CHECK-NEXT: ret %{{.*TestClassC}}* [[O2]]
sil @alloc_dynamic : $@convention(thin) (@thick TestClass.Type) -> @owned TestClass {
diff --git a/test/IRGen/typed_boxes.sil b/test/IRGen/typed_boxes.sil
index 1099955..36a7883 100644
--- a/test/IRGen/typed_boxes.sil
+++ b/test/IRGen/typed_boxes.sil
@@ -7,13 +7,13 @@
// CHECK-LABEL: define{{( protected)?}} swiftcc void @pod_box_8_8_a
sil @pod_box_8_8_a : $@convention(thin) () -> () {
entry:
- // CHECK: [[BOX:%.*]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* {{.*}} [[POD_8_8_METADATA:@metadata[0-9.]*]], i32 0, i32 2), [[WORD:i[0-9]+]] [[POD_8_8_SIZE:[0-9]+]], [[WORD]] 7)
+ // CHECK: [[BOX:%.*]] = call noalias %swift.refcounted* @swift_allocObject(%swift.type* {{.*}} [[POD_8_8_METADATA:@metadata[0-9.]*]], i32 0, i32 2), [[WORD:i[0-9]+]] [[POD_8_8_SIZE:[0-9]+]], [[WORD]] 7)
%a = alloc_box $<τ_0_0> { var τ_0_0 } <Builtin.Int64>
// CHECK: [[BOX_RAW:%.*]] = bitcast %swift.refcounted* [[BOX]] to [[POD_8_8_LAYOUT:<\{ %swift.refcounted, \[8 x i8\] \}>]]*
// CHECK: [[BOX_DATA:%.*]] = getelementptr inbounds [[POD_8_8_LAYOUT]], [[POD_8_8_LAYOUT]]* [[BOX_RAW]], i32 0, i32 1
// CHECK: [[BOX_DATA_1:%.*]] = bitcast [8 x i8]* [[BOX_DATA]] to i64*
%b = project_box %a : $<τ_0_0> { var τ_0_0 } <Builtin.Int64>, 0
- // CHECK: call void @swift_rt_swift_deallocUninitializedObject(%swift.refcounted* [[BOX]], [[WORD]] [[POD_8_8_SIZE]], [[WORD]] 7)
+ // CHECK: call void @swift_deallocUninitializedObject(%swift.refcounted* [[BOX]], [[WORD]] [[POD_8_8_SIZE]], [[WORD]] 7)
dealloc_box %a : $<τ_0_0> { var τ_0_0 } <Builtin.Int64>
return undef : $()
}
@@ -21,13 +21,13 @@
// CHECK-LABEL: define{{( protected)?}} swiftcc void @pod_box_8_8_b
sil @pod_box_8_8_b : $@convention(thin) () -> () {
entry:
- // CHECK: [[BOX:%.*]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* {{.*}} [[POD_8_8_METADATA]], i32 0, i32 2), [[WORD]] [[POD_8_8_SIZE]], [[WORD]] 7)
+ // CHECK: [[BOX:%.*]] = call noalias %swift.refcounted* @swift_allocObject(%swift.type* {{.*}} [[POD_8_8_METADATA]], i32 0, i32 2), [[WORD]] [[POD_8_8_SIZE]], [[WORD]] 7)
%a = alloc_box $<τ_0_0> { var τ_0_0 } <Builtin.FPIEEE64>
// CHECK: [[BOX_RAW:%.*]] = bitcast %swift.refcounted* [[BOX]] to [[POD_8_8_LAYOUT:<\{ %swift.refcounted, \[8 x i8\] \}>]]*
// CHECK: [[BOX_DATA:%.*]] = getelementptr inbounds [[POD_8_8_LAYOUT]], [[POD_8_8_LAYOUT]]* [[BOX_RAW]], i32 0, i32 1
// CHECK: [[BOX_DATA_1:%.*]] = bitcast [8 x i8]* [[BOX_DATA]] to double*
%b = project_box %a : $<τ_0_0> { var τ_0_0 } <Builtin.FPIEEE64>, 0
- // CHECK: call void @swift_rt_swift_deallocUninitializedObject(%swift.refcounted* [[BOX]], [[WORD]] [[POD_8_8_SIZE]], [[WORD]] 7)
+ // CHECK: call void @swift_deallocUninitializedObject(%swift.refcounted* [[BOX]], [[WORD]] [[POD_8_8_SIZE]], [[WORD]] 7)
dealloc_box %a : $<τ_0_0> { var τ_0_0 } <Builtin.FPIEEE64>
return undef : $()
}
@@ -40,14 +40,14 @@
// CHECK-LABEL: define{{( protected)?}} swiftcc void @pod_box_32_32
sil @pod_box_32_32 : $@convention(thin) () -> () {
entry:
- // CHECK: [[BOX:%.*]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* {{.*}} [[POD_32_32_METADATA:@metadata[0-9.]*]], {{.*}} [[WORD]] 64, [[WORD]] 31)
+ // CHECK: [[BOX:%.*]] = call noalias %swift.refcounted* @swift_allocObject(%swift.type* {{.*}} [[POD_32_32_METADATA:@metadata[0-9.]*]], {{.*}} [[WORD]] 64, [[WORD]] 31)
%a = alloc_box $<τ_0_0> { var τ_0_0 } <OverAligned>
// CHECK-32: [[BOX_RAW:%.*]] = bitcast %swift.refcounted* [[BOX]] to [[POD_32_32_LAYOUT:<\{ %swift.refcounted, \[24 x i8\], \[32 x i8\] \}>]]*
// CHECK-64: [[BOX_RAW:%.*]] = bitcast %swift.refcounted* [[BOX]] to [[POD_32_32_LAYOUT:<\{ %swift.refcounted, \[16 x i8\], \[32 x i8\] \}>]]*
// CHECK: [[BOX_DATA:%.*]] = getelementptr inbounds [[POD_32_32_LAYOUT]], [[POD_32_32_LAYOUT]]* [[BOX_RAW]], i32 0, i32 2
// CHECK: [[BOX_DATA_1:%.*]] = bitcast [32 x i8]* [[BOX_DATA]] to %T11typed_boxes11OverAlignedV*
%b = project_box %a : $<τ_0_0> { var τ_0_0 } <OverAligned>, 0
- // CHECK: call void @swift_rt_swift_deallocUninitializedObject(%swift.refcounted* [[BOX]], [[WORD]] 64, [[WORD]] 31)
+ // CHECK: call void @swift_deallocUninitializedObject(%swift.refcounted* [[BOX]], [[WORD]] 64, [[WORD]] 31)
dealloc_box %a : $<τ_0_0> { var τ_0_0 } <OverAligned>
return undef : $()
}
@@ -61,8 +61,8 @@
// CHECK-LABEL: define{{( protected)?}} swiftcc void @rc_box_a
sil @rc_box_a : $@convention(thin) () -> () {
entry:
- // CHECK-32: [[BOX:%.*]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* {{.*}} [[NATIVE_RC_METADATA:@metadata[0-9.]*]], {{.*}} [[WORD]] 12, [[WORD]] 3)
- // CHECK-64: [[BOX:%.*]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* {{.*}} [[NATIVE_RC_METADATA:@metadata[0-9.]*]], {{.*}} [[WORD]] 24, [[WORD]] 7)
+ // CHECK-32: [[BOX:%.*]] = call noalias %swift.refcounted* @swift_allocObject(%swift.type* {{.*}} [[NATIVE_RC_METADATA:@metadata[0-9.]*]], {{.*}} [[WORD]] 12, [[WORD]] 3)
+ // CHECK-64: [[BOX:%.*]] = call noalias %swift.refcounted* @swift_allocObject(%swift.type* {{.*}} [[NATIVE_RC_METADATA:@metadata[0-9.]*]], {{.*}} [[WORD]] 24, [[WORD]] 7)
%a = alloc_box $<τ_0_0> { var τ_0_0 } <C>
// CHECK: bitcast %swift.refcounted** {{%.*}} to %T11typed_boxes1CC**
%b = project_box %a : $<τ_0_0> { var τ_0_0 } <C>, 0
@@ -74,8 +74,8 @@
sil @rc_box_b : $@convention(thin) () -> () {
entry:
// TODO: Should reuse metadata
- // CHECK-32: [[BOX:%.*]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* {{.*}} [[NATIVE_RC_METADATA]], {{.*}} [[WORD]] 12, [[WORD]] 3)
- // CHECK-64: [[BOX:%.*]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* {{.*}} [[NATIVE_RC_METADATA]], {{.*}} [[WORD]] 24, [[WORD]] 7)
+ // CHECK-32: [[BOX:%.*]] = call noalias %swift.refcounted* @swift_allocObject(%swift.type* {{.*}} [[NATIVE_RC_METADATA]], {{.*}} [[WORD]] 12, [[WORD]] 3)
+ // CHECK-64: [[BOX:%.*]] = call noalias %swift.refcounted* @swift_allocObject(%swift.type* {{.*}} [[NATIVE_RC_METADATA]], {{.*}} [[WORD]] 24, [[WORD]] 7)
%a = alloc_box $<τ_0_0> { var τ_0_0 } <D>
// CHECK: bitcast %swift.refcounted** {{%.*}} to %T11typed_boxes1DC**
%b = project_box %a : $<τ_0_0> { var τ_0_0 } <D>, 0
@@ -86,8 +86,8 @@
// CHECK-LABEL: define{{( protected)?}} swiftcc void @unknown_rc_box
sil @unknown_rc_box : $@convention(thin) () -> () {
entry:
- // CHECK-32: [[BOX:%.*]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* {{.*}} [[UNKNOWN_RC_METADATA:@metadata[0-9.]*]], {{.*}} [[WORD]] 12, [[WORD]] 3)
- // CHECK-64: [[BOX:%.*]] = call noalias %swift.refcounted* @swift_rt_swift_allocObject(%swift.type* {{.*}} [[UNKNOWN_RC_METADATA:@metadata[0-9.]*]], {{.*}} [[WORD]] 24, [[WORD]] 7)
+ // CHECK-32: [[BOX:%.*]] = call noalias %swift.refcounted* @swift_allocObject(%swift.type* {{.*}} [[UNKNOWN_RC_METADATA:@metadata[0-9.]*]], {{.*}} [[WORD]] 12, [[WORD]] 3)
+ // CHECK-64: [[BOX:%.*]] = call noalias %swift.refcounted* @swift_allocObject(%swift.type* {{.*}} [[UNKNOWN_RC_METADATA:@metadata[0-9.]*]], {{.*}} [[WORD]] 24, [[WORD]] 7)
%a = alloc_box $<τ_0_0> { var τ_0_0 } <Builtin.UnknownObject>
%b = project_box %a : $<τ_0_0> { var τ_0_0 } <Builtin.UnknownObject>, 0
dealloc_box %a : $<τ_0_0> { var τ_0_0 } <Builtin.UnknownObject>
diff --git a/test/IRGen/typemetadata.sil b/test/IRGen/typemetadata.sil
index 586f9b3..2c125f9 100644
--- a/test/IRGen/typemetadata.sil
+++ b/test/IRGen/typemetadata.sil
@@ -30,7 +30,7 @@
// CHECK: [[T0:%.*]] = load %swift.type*, %swift.type** @"$S12typemetadata1CCML", align 8
// CHECK-NEXT: [[T1:%.*]] = icmp eq %swift.type* [[T0]], null
// CHECK-NEXT: br i1 [[T1]]
-// CHECK: [[T0:%.*]] = call %objc_class* @swift_rt_swift_getInitializedObjCClass({{.*}} @"$S12typemetadata1CCMf", {{.*}})
+// CHECK: [[T0:%.*]] = call %objc_class* @swift_getInitializedObjCClass({{.*}} @"$S12typemetadata1CCMf", {{.*}})
// CHECK-NEXT: [[T1:%.*]] = bitcast %objc_class* [[T0]] to %swift.type*
// CHECK: store atomic %swift.type* [[T1]], %swift.type** @"$S12typemetadata1CCML" release, align 8
// CHECK-NEXT: br label
diff --git a/test/IRGen/unowned.sil b/test/IRGen/unowned.sil
index f2ffd02..d58e1e2 100644
--- a/test/IRGen/unowned.sil
+++ b/test/IRGen/unowned.sil
@@ -31,8 +31,8 @@
return %3 : $()
}
// CHECK: define{{( protected)?}} swiftcc void @test_weak_rr_class([[C]]*) {{.*}} {
-// CHECK: call [[C]]* bitcast ([[REF]]* ([[REF]]*)* @swift_rt_swift_unownedRetain to [[C]]* ([[C]]*)*)([[C]]* returned %0)
-// CHECK-NEXT: call void bitcast (void ([[REF]]*)* @swift_rt_swift_unownedRelease to void ([[C]]*)*)([[C]]* %0)
+// CHECK: call [[C]]* bitcast ([[REF]]* ([[REF]]*)* @swift_unownedRetain to [[C]]* ([[C]]*)*)([[C]]* returned %0)
+// CHECK-NEXT: call void bitcast (void ([[REF]]*)* @swift_unownedRelease to void ([[C]]*)*)([[C]]* %0)
// CHECK-NEXT: ret void
sil @test_weak_rr_proto : $@convention(thin) (@sil_unowned P) -> () {
@@ -43,8 +43,8 @@
return %3 : $()
}
// CHECK: define{{( protected)?}} swiftcc void @test_weak_rr_proto(%swift.refcounted*, i8**) {{.*}} {
-// CHECK: call %swift.refcounted* @swift_rt_swift_unownedRetain(%swift.refcounted* returned %0)
-// CHECK: call void @swift_rt_swift_unownedRelease(%swift.refcounted* %0)
+// CHECK: call %swift.refcounted* @swift_unownedRetain(%swift.refcounted* returned %0)
+// CHECK: call void @swift_unownedRelease(%swift.refcounted* %0)
// CHECK-NEXT: ret void
// Value witnesses for A:
@@ -57,7 +57,7 @@
// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[A]], [[A]]* [[SRC]], i32 0, i32 0
// CHECK-NEXT: [[T1C:%.*]] = bitcast %swift.unowned* [[T1]] to [[C]]*
// CHECK-NEXT: [[T2:%.*]] = load [[C]]*, [[C]]** [[T1C]], align 8
-// CHECK-NEXT: call [[C]]* bitcast ([[REF]]* ([[REF]]*)* @swift_rt_swift_unownedRetain to [[C]]* ([[C]]*)*)([[C]]* returned [[T2]])
+// CHECK-NEXT: call [[C]]* bitcast ([[REF]]* ([[REF]]*)* @swift_unownedRetain to [[C]]* ([[C]]*)*)([[C]]* returned [[T2]])
// CHECK-NEXT: [[T0C:%.*]] = bitcast %swift.unowned* [[T0]] to [[C]]*
// CHECK-NEXT: store [[C]]* [[T2]], [[C]]** [[T0C]], align 8
// CHECK-NEXT: [[T0:%.*]] = bitcast [[A]]* [[DEST]] to [[OPAQUE]]*
@@ -69,7 +69,7 @@
// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[A]], [[A]]* [[T0]], i32 0, i32 0
// CHECK-NEXT: [[T1C:%.*]] = bitcast %swift.unowned* [[T1]] to [[C]]*
// CHECK-NEXT: [[T2:%.*]] = load [[C]]*, [[C]]** [[T1C]], align 8
-// CHECK-NEXT: call void bitcast (void ([[REF]]*)* @swift_rt_swift_unownedRelease to void ([[C]]*)*)([[C]]* [[T2]])
+// CHECK-NEXT: call void bitcast (void ([[REF]]*)* @swift_unownedRelease to void ([[C]]*)*)([[C]]* [[T2]])
// CHECK-NEXT: ret void
// initializeWithCopy
@@ -80,7 +80,7 @@
// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[A]], [[A]]* [[SRC]], i32 0, i32 0
// CHECK-NEXT: [[T1C:%.*]] = bitcast %swift.unowned* [[T1]] to [[C]]*
// CHECK-NEXT: [[T2:%.*]] = load [[C]]*, [[C]]** [[T1C]], align 8
-// CHECK-NEXT: call [[C]]* bitcast ([[REF]]* ([[REF]]*)* @swift_rt_swift_unownedRetain to [[C]]* ([[C]]*)*)([[C]]* returned [[T2]])
+// CHECK-NEXT: call [[C]]* bitcast ([[REF]]* ([[REF]]*)* @swift_unownedRetain to [[C]]* ([[C]]*)*)([[C]]* returned [[T2]])
// CHECK-NEXT: [[T0C:%.*]] = bitcast %swift.unowned* [[T0]] to [[C]]*
// CHECK-NEXT: store [[C]]* [[T2]], [[C]]** [[T0C]], align 8
// CHECK-NEXT: [[T0:%.*]] = bitcast [[A]]* [[DEST]] to [[OPAQUE]]*
@@ -94,11 +94,11 @@
// CHECK-NEXT: [[SRC_X:%.*]] = getelementptr inbounds [[A]], [[A]]* [[SRC]], i32 0, i32 0
// CHECK-NEXT: [[SRC_X_C:%.*]] = bitcast %swift.unowned* [[SRC_X]] to [[C]]*
// CHECK-NEXT: [[NEW:%.*]] = load [[C]]*, [[C]]** [[SRC_X_C]], align 8
-// CHECK-NEXT: call [[C]]* bitcast ([[REF]]* ([[REF]]*)* @swift_rt_swift_unownedRetain to [[C]]* ([[C]]*)*)([[C]]* returned [[NEW]])
+// CHECK-NEXT: call [[C]]* bitcast ([[REF]]* ([[REF]]*)* @swift_unownedRetain to [[C]]* ([[C]]*)*)([[C]]* returned [[NEW]])
// CHECK-NEXT: [[DEST_X_C:%.*]] = bitcast %swift.unowned* [[DEST_X]] to [[C]]*
// CHECK-NEXT: [[OLD:%.*]] = load [[C]]*, [[C]]** [[DEST_X_C]], align 8
// CHECK-NEXT: store [[C]]* [[NEW]], [[C]]** [[DEST_X_C]], align 8
-// CHECK-NEXT: call void bitcast (void ([[REF]]*)* @swift_rt_swift_unownedRelease to void ([[C]]*)*)([[C]]* [[OLD]])
+// CHECK-NEXT: call void bitcast (void ([[REF]]*)* @swift_unownedRelease to void ([[C]]*)*)([[C]]* [[OLD]])
// CHECK-NEXT: [[T0:%.*]] = bitcast [[A]]* [[DEST]] to [[OPAQUE]]*
// CHECK-NEXT: ret [[OPAQUE]]* [[T0]]
@@ -113,6 +113,6 @@
// CHECK-NEXT: [[DEST_X_C:%.*]] = bitcast %swift.unowned* [[DEST_X]] to [[C]]*
// CHECK-NEXT: [[OLD:%.*]] = load [[C]]*, [[C]]** [[DEST_X_C]], align 8
// CHECK-NEXT: store [[C]]* [[NEW]], [[C]]** [[DEST_X_C]], align 8
-// CHECK-NEXT: call void bitcast (void ([[REF]]*)* @swift_rt_swift_unownedRelease to void ([[C]]*)*)([[C]]* [[OLD]])
+// CHECK-NEXT: call void bitcast (void ([[REF]]*)* @swift_unownedRelease to void ([[C]]*)*)([[C]]* [[OLD]])
// CHECK-NEXT: [[T0:%.*]] = bitcast [[A]]* [[DEST]] to [[OPAQUE]]*
// CHECK-NEXT: ret [[OPAQUE]]* [[T0]]
diff --git a/test/IRGen/unowned_objc.sil b/test/IRGen/unowned_objc.sil
index 5f63d15..cb8f039 100644
--- a/test/IRGen/unowned_objc.sil
+++ b/test/IRGen/unowned_objc.sil
@@ -6,11 +6,11 @@
import Builtin
// These types end up in a completely different order with interop disabled.
-// CHECK: [[TYPE:%swift.type]] = type
-// CHECK: [[OPAQUE:%swift.opaque]] = type opaque
-// CHECK: [[C:%T12unowned_objc1CC]] = type <{ [[REF:%swift.refcounted]] }>
-// CHECK: [[UNKNOWN:%objc_object]] = type
-// CHECK: [[A:%T12unowned_objc1AV]] = type <{ %swift.unowned }>
+// CHECK-DAG: [[TYPE:%swift.type]] = type
+// CHECK-DAG: [[OPAQUE:%swift.opaque]] = type opaque
+// CHECK-DAG: [[C:%T12unowned_objc1CC]] = type <{ [[REF:%swift.refcounted]] }>
+// CHECK-DAG: [[UNKNOWN:%objc_object]] = type
+// CHECK-DAG: [[A:%T12unowned_objc1AV]] = type <{ %swift.unowned }>
class C {}
sil_vtable C {}
@@ -37,8 +37,8 @@
return %3 : $()
}
// CHECK: define{{( protected)?}} swiftcc void @test_weak_rr_class([[C]]*) {{.*}} {
-// CHECK: call [[C]]* bitcast ([[REF]]* ([[REF]]*)* @swift_rt_swift_unownedRetain to [[C]]* ([[C]]*)*)([[C]]* returned %0)
-// CHECK-NEXT: call void bitcast (void ([[REF]]*)* @swift_rt_swift_unownedRelease to void ([[C]]*)*)([[C]]* %0)
+// CHECK: call [[C]]* bitcast ([[REF]]* ([[REF]]*)* @swift_unownedRetain to [[C]]* ([[C]]*)*)([[C]]* returned %0)
+// CHECK-NEXT: call void bitcast (void ([[REF]]*)* @swift_unownedRelease to void ([[C]]*)*)([[C]]* %0)
// CHECK-NEXT: ret void
// CHECK: define{{( protected)?}} swiftcc void @test_unknown_unowned_copies([[UNKNOWN]]*, i8**, [[UNKNOWN]]*, i8**)
@@ -134,7 +134,7 @@
// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[A]], [[A]]* [[SRC]], i32 0, i32 0
// CHECK-NEXT: [[T1C:%.*]] = bitcast %swift.unowned* [[T1]] to [[C]]*
// CHECK-NEXT: [[T2:%.*]] = load [[C]]*, [[C]]** [[T1C]], align 8
-// CHECK-NEXT: call [[C]]* bitcast ([[REF]]* ([[REF]]*)* @swift_rt_swift_unownedRetain to [[C]]* ([[C]]*)*)([[C]]* returned [[T2]])
+// CHECK-NEXT: call [[C]]* bitcast ([[REF]]* ([[REF]]*)* @swift_unownedRetain to [[C]]* ([[C]]*)*)([[C]]* returned [[T2]])
// CHECK-NEXT: [[T0C:%.*]] = bitcast %swift.unowned* [[T0]] to [[C]]*
// CHECK-NEXT: store [[C]]* [[T2]], [[C]]** [[T0C]], align 8
// CHECK-NEXT: [[T0:%.*]] = bitcast [[A]]* [[DEST]] to [[OPAQUE]]*
@@ -146,7 +146,7 @@
// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[A]], [[A]]* [[T0]], i32 0, i32 0
// CHECK-NEXT: [[T1C:%.*]] = bitcast %swift.unowned* [[T1]] to [[C]]*
// CHECK-NEXT: [[T2:%.*]] = load [[C]]*, [[C]]** [[T1C]], align 8
-// CHECK-NEXT: call void bitcast (void ([[REF]]*)* @swift_rt_swift_unownedRelease to void ([[C]]*)*)([[C]]* [[T2]])
+// CHECK-NEXT: call void bitcast (void ([[REF]]*)* @swift_unownedRelease to void ([[C]]*)*)([[C]]* [[T2]])
// CHECK-NEXT: ret void
// initializeWithCopy
@@ -157,7 +157,7 @@
// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[A]], [[A]]* [[SRC]], i32 0, i32 0
// CHECK-NEXT: [[T1C:%.*]] = bitcast %swift.unowned* [[T1]] to [[C]]*
// CHECK-NEXT: [[T2:%.*]] = load [[C]]*, [[C]]** [[T1C]], align 8
-// CHECK-NEXT: call [[C]]* bitcast ([[REF]]* ([[REF]]*)* @swift_rt_swift_unownedRetain to [[C]]* ([[C]]*)*)([[C]]* returned [[T2]])
+// CHECK-NEXT: call [[C]]* bitcast ([[REF]]* ([[REF]]*)* @swift_unownedRetain to [[C]]* ([[C]]*)*)([[C]]* returned [[T2]])
// CHECK-NEXT: [[T0C:%.*]] = bitcast %swift.unowned* [[T0]] to [[C]]*
// CHECK-NEXT: store [[C]]* [[T2]], [[C]]** [[T0C]], align 8
// CHECK-NEXT: [[T0:%.*]] = bitcast [[A]]* [[DEST]] to [[OPAQUE]]*
@@ -171,11 +171,11 @@
// CHECK-NEXT: [[SRC_X:%.*]] = getelementptr inbounds [[A]], [[A]]* [[SRC]], i32 0, i32 0
// CHECK-NEXT: [[SRC_X_C:%.*]] = bitcast %swift.unowned* [[SRC_X]] to [[C]]*
// CHECK-NEXT: [[NEW:%.*]] = load [[C]]*, [[C]]** [[SRC_X_C]], align 8
-// CHECK-NEXT: call [[C]]* bitcast ([[REF]]* ([[REF]]*)* @swift_rt_swift_unownedRetain to [[C]]* ([[C]]*)*)([[C]]* returned [[NEW]])
+// CHECK-NEXT: call [[C]]* bitcast ([[REF]]* ([[REF]]*)* @swift_unownedRetain to [[C]]* ([[C]]*)*)([[C]]* returned [[NEW]])
// CHECK-NEXT: [[DEST_X_C:%.*]] = bitcast %swift.unowned* [[DEST_X]] to [[C]]*
// CHECK-NEXT: [[OLD:%.*]] = load [[C]]*, [[C]]** [[DEST_X_C]], align 8
// CHECK-NEXT: store [[C]]* [[NEW]], [[C]]** [[DEST_X_C]], align 8
-// CHECK-NEXT: call void bitcast (void ([[REF]]*)* @swift_rt_swift_unownedRelease to void ([[C]]*)*)([[C]]* [[OLD]])
+// CHECK-NEXT: call void bitcast (void ([[REF]]*)* @swift_unownedRelease to void ([[C]]*)*)([[C]]* [[OLD]])
// CHECK-NEXT: [[T0:%.*]] = bitcast [[A]]* [[DEST]] to [[OPAQUE]]*
// CHECK-NEXT: ret [[OPAQUE]]* [[T0]]
@@ -190,6 +190,6 @@
// CHECK-NEXT: [[DEST_X_C:%.*]] = bitcast %swift.unowned* [[DEST_X]] to [[C]]*
// CHECK-NEXT: [[OLD:%.*]] = load [[C]]*, [[C]]** [[DEST_X_C]], align 8
// CHECK-NEXT: store [[C]]* [[NEW]], [[C]]** [[DEST_X_C]], align 8
-// CHECK-NEXT: call void bitcast (void ([[REF]]*)* @swift_rt_swift_unownedRelease to void ([[C]]*)*)([[C]]* [[OLD]])
+// CHECK-NEXT: call void bitcast (void ([[REF]]*)* @swift_unownedRelease to void ([[C]]*)*)([[C]]* [[OLD]])
// CHECK-NEXT: [[T0:%.*]] = bitcast [[A]]* [[DEST]] to [[OPAQUE]]*
// CHECK-NEXT: ret [[OPAQUE]]* [[T0]]
diff --git a/test/IRGen/value_buffers.sil b/test/IRGen/value_buffers.sil
index 75950e2..67d1bfb 100644
--- a/test/IRGen/value_buffers.sil
+++ b/test/IRGen/value_buffers.sil
@@ -58,7 +58,7 @@
}
// CHECK-LABEL: define{{( protected)?}} swiftcc void @alloc_big([24 x i8]* nocapture dereferenceable({{.*}}), %T13value_buffers9BigStructV* noalias nocapture dereferenceable({{.*}}))
// CHECK-NEXT: entry:
-// CHECK-NEXT: [[T0:%.*]] = call noalias i8* @swift_rt_swift_slowAlloc(i64 48, i64 7)
+// CHECK-NEXT: [[T0:%.*]] = call noalias i8* @swift_slowAlloc(i64 48, i64 7)
// CHECK-NEXT: [[T1:%.*]] = bitcast [24 x i8]* %0 to i8**
// CHECK-NEXT: store i8* [[T0]], i8** [[T1]], align 8
// CHECK-NEXT: [[ADDR:%.*]] = bitcast i8* [[T0]] to %T13value_buffers9BigStructV*
@@ -93,5 +93,5 @@
// CHECK-NEXT: entry:
// CHECK-NEXT: [[T0:%.*]] = bitcast [24 x i8]* %0 to i8**
// CHECK-NEXT: [[ADDR:%.*]] = load i8*, i8** [[T0]], align 8
-// CHECK-NEXT: call void @swift_rt_swift_slowDealloc(i8* [[ADDR]], i64 48, i64 7)
+// CHECK-NEXT: call void @swift_slowDealloc(i8* [[ADDR]], i64 48, i64 7)
// CHECK-NEXT: ret void
diff --git a/test/IRGen/weak.sil b/test/IRGen/weak.sil
index 7650f35..6f23e84 100644
--- a/test/IRGen/weak.sil
+++ b/test/IRGen/weak.sil
@@ -4,13 +4,13 @@
// REQUIRES: CPU=x86_64
// XFAIL: linux
-// CHECK: [[TYPE:%swift.type]] = type
-// CHECK: [[OPAQUE:%swift.opaque]] = type opaque
-// CHECK: [[C:%T4weak1CC]] = type <{ [[REF:%swift.refcounted]] }>
-// CHECK: [[UNKNOWN:%objc_object]] = type opaque
-// CHECK: [[A:%T4weak1AV]] = type <{ [[WEAK:%swift.weak]] }>
-// CHECK: [[WEAK]] = type
-// CHECK: [[B:%T4weak1BV]] = type <{ { [[WEAK]], i8** } }>
+// CHECK-DAG: [[TYPE:%swift.type]] = type
+// CHECK-DAG: [[OPAQUE:%swift.opaque]] = type opaque
+// CHECK-DAG: [[C:%T4weak1CC]] = type <{ [[REF:%swift.refcounted]] }>
+// CHECK-DAG: [[UNKNOWN:%objc_object]] = type opaque
+// CHECK-DAG: [[A:%T4weak1AV]] = type <{ [[WEAK:%swift.weak]] }>
+// CHECK-DAG: [[WEAK]] = type
+// CHECK-DAG: [[B:%T4weak1BV]] = type <{ { [[WEAK]], i8** } }>
sil_stage canonical
@@ -49,7 +49,7 @@
// CHECK-NEXT: %4 = inttoptr
// CHECK-NEXT: call [[WEAK]]* bitcast ([[WEAK]]* ([[WEAK]]*, [[REF]]*)* @swift_weakAssign to [[WEAK]]* ([[WEAK]]*, [[C]]*)*)([[WEAK]]* returned [[X]], [[C]]* %4)
// CHECK-NEXT: %6 = inttoptr i64 %3 to %swift.refcounted*
-// CHECK-NEXT: call void @swift_rt_swift_release([[REF]]* %6)
+// CHECK-NEXT: call void @swift_release([[REF]]* %6)
// CHECK-NEXT: ret void
struct B {
diff --git a/test/IRGen/yield_once_big.sil b/test/IRGen/yield_once_big.sil
index 8f55e67..91f9c33 100644
--- a/test/IRGen/yield_once_big.sil
+++ b/test/IRGen/yield_once_big.sil
@@ -150,14 +150,14 @@
br cont
cont:
- // CHECK: call void bitcast (void (%swift.refcounted*)* @swift_rt_swift_release to void (%T14yield_once_big12SomeSubclassC*)*)(%T14yield_once_big12SomeSubclassC* [[R0]])
- // CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_rt_swift_release to void (%T14yield_once_big12SomeSubclassC*)*)(%T14yield_once_big12SomeSubclassC* [[R1]])
- // CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_rt_swift_release to void (%T14yield_once_big12SomeSubclassC*)*)(%T14yield_once_big12SomeSubclassC* [[R2]])
- // CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_rt_swift_release to void (%T14yield_once_big12SomeSubclassC*)*)(%T14yield_once_big12SomeSubclassC* [[R3]])
- // CHECK: call void bitcast (void (%swift.refcounted*)* @swift_rt_swift_release to void (%T14yield_once_big12SomeSubclassC*)*)(%T14yield_once_big12SomeSubclassC* [[R4]])
- // CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_rt_swift_release to void (%T14yield_once_big12SomeSubclassC*)*)(%T14yield_once_big12SomeSubclassC* [[R5]])
- // CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_rt_swift_release to void (%T14yield_once_big12SomeSubclassC*)*)(%T14yield_once_big12SomeSubclassC* [[R6]])
- // CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_rt_swift_release to void (%T14yield_once_big12SomeSubclassC*)*)(%T14yield_once_big12SomeSubclassC* [[R7]])
+ // CHECK: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T14yield_once_big12SomeSubclassC*)*)(%T14yield_once_big12SomeSubclassC* [[R0]])
+ // CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T14yield_once_big12SomeSubclassC*)*)(%T14yield_once_big12SomeSubclassC* [[R1]])
+ // CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T14yield_once_big12SomeSubclassC*)*)(%T14yield_once_big12SomeSubclassC* [[R2]])
+ // CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T14yield_once_big12SomeSubclassC*)*)(%T14yield_once_big12SomeSubclassC* [[R3]])
+ // CHECK: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T14yield_once_big12SomeSubclassC*)*)(%T14yield_once_big12SomeSubclassC* [[R4]])
+ // CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T14yield_once_big12SomeSubclassC*)*)(%T14yield_once_big12SomeSubclassC* [[R5]])
+ // CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T14yield_once_big12SomeSubclassC*)*)(%T14yield_once_big12SomeSubclassC* [[R6]])
+ // CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T14yield_once_big12SomeSubclassC*)*)(%T14yield_once_big12SomeSubclassC* [[R7]])
destroy_value %value : $Big<SomeSubclass>
// CHECK-NEXT: ret void
diff --git a/test/IRGen/yield_once_biggish.sil b/test/IRGen/yield_once_biggish.sil
index dcfefd2..47ba598 100644
--- a/test/IRGen/yield_once_biggish.sil
+++ b/test/IRGen/yield_once_biggish.sil
@@ -150,10 +150,10 @@
br cont
cont:
- // CHECK: call void bitcast (void (%swift.refcounted*)* @swift_rt_swift_release to void (%T18yield_once_biggish12SomeSubclassC*)*)(%T18yield_once_biggish12SomeSubclassC* [[R0]])
- // CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_rt_swift_release to void (%T18yield_once_biggish12SomeSubclassC*)*)(%T18yield_once_biggish12SomeSubclassC* [[R1]])
- // CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_rt_swift_release to void (%T18yield_once_biggish12SomeSubclassC*)*)(%T18yield_once_biggish12SomeSubclassC* [[R2]])
- // CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_rt_swift_release to void (%T18yield_once_biggish12SomeSubclassC*)*)(%T18yield_once_biggish12SomeSubclassC* [[R3]])
+ // CHECK: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T18yield_once_biggish12SomeSubclassC*)*)(%T18yield_once_biggish12SomeSubclassC* [[R0]])
+ // CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T18yield_once_biggish12SomeSubclassC*)*)(%T18yield_once_biggish12SomeSubclassC* [[R1]])
+ // CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T18yield_once_biggish12SomeSubclassC*)*)(%T18yield_once_biggish12SomeSubclassC* [[R2]])
+ // CHECK-NEXT: call void bitcast (void (%swift.refcounted*)* @swift_release to void (%T18yield_once_biggish12SomeSubclassC*)*)(%T18yield_once_biggish12SomeSubclassC* [[R3]])
destroy_value %value : $Biggish<SomeSubclass>
// CHECK-NEXT: ret void
diff --git a/test/Inputs/conditional_conformance_basic_conformances.swift b/test/Inputs/conditional_conformance_basic_conformances.swift
index 10fb901..79f5d93 100644
--- a/test/Inputs/conditional_conformance_basic_conformances.swift
+++ b/test/Inputs/conditional_conformance_basic_conformances.swift
@@ -69,7 +69,7 @@
// CHECK-NEXT: [[COUNT_PTR:%.*]] = getelementptr inbounds %swift.witness_table_slice, %swift.witness_table_slice* %conditional.tables, i32 0, i32 1
// CHECK-NEXT: store i64 %2, i64* [[COUNT_PTR]], align 8
// CHECK-NEXT: [[CAST_CONDITIONAL_TABLES:%.*]] = bitcast %swift.witness_table_slice* %conditional.tables to i8**
-// CHECK-NEXT: [[TABLE:%.*]] = call i8** @swift_rt_swift_getGenericWitnessTable(%swift.generic_witness_table_cache* @"$S42conditional_conformance_basic_conformances6SingleVyxGAA2P1A2A2P2RzlWG", %swift.type* %0, i8** [[CAST_CONDITIONAL_TABLES]])
+// CHECK-NEXT: [[TABLE:%.*]] = call i8** @swift_getGenericWitnessTable(%swift.generic_witness_table_cache* @"$S42conditional_conformance_basic_conformances6SingleVyxGAA2P1A2A2P2RzlWG", %swift.type* %0, i8** [[CAST_CONDITIONAL_TABLES]])
// CHECK-NEXT: ret i8** [[TABLE]]
// CHECK-NEXT: }
@@ -197,7 +197,7 @@
// CHECK-NEXT: [[COUNT_PTR:%.*]] = getelementptr inbounds %swift.witness_table_slice, %swift.witness_table_slice* %conditional.tables, i32 0, i32 1
// CHECK-NEXT: store i64 %2, i64* [[COUNT_PTR]], align 8
// CHECK-NEXT: [[CAST_CONDITIONAL_TABLES:%.*]] = bitcast %swift.witness_table_slice* %conditional.tables to i8**
-// CHECK-NEXT: [[TABLE:%.*]] = call i8** @swift_rt_swift_getGenericWitnessTable(%swift.generic_witness_table_cache* @"$S42conditional_conformance_basic_conformances6DoubleVyxq_GAA2P1A2A2P2RzAA2P3R_rlWG", %swift.type* %0, i8** [[CAST_CONDITIONAL_TABLES]])
+// CHECK-NEXT: [[TABLE:%.*]] = call i8** @swift_getGenericWitnessTable(%swift.generic_witness_table_cache* @"$S42conditional_conformance_basic_conformances6DoubleVyxq_GAA2P1A2A2P2RzAA2P3R_rlWG", %swift.type* %0, i8** [[CAST_CONDITIONAL_TABLES]])
// CHECK-NEXT: ret i8** [[TABLE]]
// CHECK-NEXT: }
diff --git a/test/Inputs/conditional_conformance_subclass.swift b/test/Inputs/conditional_conformance_subclass.swift
index 878f55e..3bbf4af 100644
--- a/test/Inputs/conditional_conformance_subclass.swift
+++ b/test/Inputs/conditional_conformance_subclass.swift
@@ -69,7 +69,7 @@
// CHECK-NEXT: [[COUNT_PTR:%.*]] = getelementptr inbounds %swift.witness_table_slice, %swift.witness_table_slice* %conditional.tables, i32 0, i32 1
// CHECK-NEXT: store i64 %2, i64* [[COUNT_PTR]], align 8
// CHECK-NEXT: [[CAST_CONDITIONAL_TABLES:%.*]] = bitcast %swift.witness_table_slice* %conditional.tables to i8**
-// CHECK-NEXT: [[TABLE:%.*]] = call i8** @swift_rt_swift_getGenericWitnessTable(%swift.generic_witness_table_cache* @"$S32conditional_conformance_subclass4BaseCyxGAA2P1A2A2P2RzlWG", %swift.type* %0, i8** [[CAST_CONDITIONAL_TABLES]])
+// CHECK-NEXT: [[TABLE:%.*]] = call i8** @swift_getGenericWitnessTable(%swift.generic_witness_table_cache* @"$S32conditional_conformance_subclass4BaseCyxGAA2P1A2A2P2RzlWG", %swift.type* %0, i8** [[CAST_CONDITIONAL_TABLES]])
// CHECK-NEXT: ret i8** [[TABLE]]
// CHECK-NEXT: }
diff --git a/test/Inputs/conditional_conformance_with_assoc.swift b/test/Inputs/conditional_conformance_with_assoc.swift
index 3d35d1b..b43816a 100644
--- a/test/Inputs/conditional_conformance_with_assoc.swift
+++ b/test/Inputs/conditional_conformance_with_assoc.swift
@@ -180,8 +180,8 @@
// CHECK-LABEL: define{{( protected)?}} swiftcc void @"$S34conditional_conformance_with_assoc09concrete_E0yyF"() #0 {
// CHECK-NEXT: entry:
-// CHECK-NEXT: %0 = call %swift.type* @"$S34conditional_conformance_with_assoc6DoubleVyAA8IsAlsoP2VAA0F2P3VGMa"() #10
-// CHECK-NEXT: %1 = call i8** @"$S34conditional_conformance_with_assoc6DoubleVyAA8IsAlsoP2VAA0F2P3VGACyxq_GAA2P1A2A0I0R_AA0H03AT2RpzAakM_AmaLP3AT3RPzrlWl"() #10
+// CHECK-NEXT: %0 = call %swift.type* @"$S34conditional_conformance_with_assoc6DoubleVyAA8IsAlsoP2VAA0F2P3VGMa"()
+// CHECK-NEXT: %1 = call i8** @"$S34conditional_conformance_with_assoc6DoubleVyAA8IsAlsoP2VAA0F2P3VGACyxq_GAA2P1A2A0I0R_AA0H03AT2RpzAakM_AmaLP3AT3RPzrlWl"()
// CHECK-NEXT: call swiftcc void @"$S34conditional_conformance_with_assoc8takes_p1yyxmAA2P1RzlF"(%swift.type* %0, %swift.type* %0, i8** %1)
// CHECK-NEXT: ret void
// CHECK-NEXT: }
@@ -196,7 +196,7 @@
// CHECK-NEXT: br i1 [[IS_NULL]], label %cacheIsNull, label %cont
// CHECK: cacheIsNull:
-// CHECK-NEXT: [[Double_TYPE:%.*]] = call %swift.type* @"$S34conditional_conformance_with_assoc6DoubleVyAA8IsAlsoP2VAA0F2P3VGMa"() #10
+// CHECK-NEXT: [[Double_TYPE:%.*]] = call %swift.type* @"$S34conditional_conformance_with_assoc6DoubleVyAA8IsAlsoP2VAA0F2P3VGMa"()
// CHECK-NEXT: [[CONDITIONAL_REQUIREMENTS:%.*]] = getelementptr inbounds [3 x i8**], [3 x i8**]* %conditional.requirement.buffer, i32 0, i32 0
// CHECK-NEXT: [[C_P3_PTR:%.*]] = getelementptr inbounds i8**, i8*** [[CONDITIONAL_REQUIREMENTS]], i32 0
// CHECK-NEXT: store i8** getelementptr inbounds ([2 x i8*], [2 x i8*]* @"$S34conditional_conformance_with_assoc4IsP3VAA0F0AAWP", i32 0, i32 0), i8*** [[C_P3_PTR]], align 8
diff --git a/test/Interpreter/enum.swift b/test/Interpreter/enum.swift
index 37cba79..2a44c7d 100644
--- a/test/Interpreter/enum.swift
+++ b/test/Interpreter/enum.swift
@@ -651,3 +651,19 @@
}
run()
+
+public enum Indirect<T> {
+ indirect case payload((T, other: T))
+ case none
+}
+
+public func testIndirectEnum<T>(_ payload: T) -> Indirect<T> {
+ return Indirect.payload((payload, other: payload))
+}
+
+public func testCase(_ closure: @escaping (Int) -> ()) -> Indirect<(Int) -> ()> {
+ return testIndirectEnum(closure)
+}
+
+// CHECK: payload((Function), other: (Function))
+print(testCase({ _ in }))
diff --git a/test/LLVMPasses/basic.ll b/test/LLVMPasses/basic.ll
index 7946dbb..52ca7be 100644
--- a/test/LLVMPasses/basic.ll
+++ b/test/LLVMPasses/basic.ll
@@ -8,16 +8,16 @@
%objc_object = type opaque
%swift.bridge = type opaque
-declare void @swift_unknownRetain(%swift.refcounted*)
+declare %swift.refcounted* @swift_unknownRetain(%swift.refcounted* returned)
declare void @swift_unknownRelease(%swift.refcounted*)
declare %objc_object* @objc_retain(%objc_object*)
declare void @objc_release(%objc_object*)
declare %swift.refcounted* @swift_allocObject(%swift.heapmetadata* , i64, i64) nounwind
declare void @swift_release(%swift.refcounted* nocapture)
-declare void @swift_retain(%swift.refcounted* ) nounwind
+declare %swift.refcounted* @swift_retain(%swift.refcounted* returned) nounwind
declare %swift.bridge* @swift_bridgeObjectRetain(%swift.bridge*)
declare void @swift_bridgeObjectRelease(%swift.bridge*)
-declare void @swift_retainUnowned(%swift.refcounted*)
+declare %swift.refcounted* @swift_retainUnowned(%swift.refcounted* returned)
declare void @user(%swift.refcounted *) nounwind
declare void @user_objc(%objc_object*) nounwind
@@ -50,9 +50,9 @@
define void @trivial_retain_release(%swift.refcounted* %P, %objc_object* %O, %swift.bridge * %B) {
entry:
- tail call void @swift_retain(%swift.refcounted* %P)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %P)
tail call void @swift_release(%swift.refcounted* %P) nounwind
- tail call void @swift_unknownRetain(%swift.refcounted* %P)
+ tail call %swift.refcounted* @swift_unknownRetain(%swift.refcounted* %P)
tail call void @swift_unknownRelease(%swift.refcounted* %P)
tail call %objc_object* @objc_retain(%objc_object* %O)
tail call void @objc_release(%objc_object* %O)
@@ -72,15 +72,15 @@
define void @trivial_retain_release_with_rcidentity(%swift.refcounted* %P, %objc_object* %O, %swift.bridge * %B) {
entry:
- tail call void @swift_retain(%swift.refcounted* %P)
- %0 = bitcast %swift.refcounted* %P to %swift.refcounted*
- tail call void @swift_release(%swift.refcounted* %0) nounwind
- tail call void @swift_unknownRetain(%swift.refcounted* %P)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %P)
%1 = bitcast %swift.refcounted* %P to %swift.refcounted*
- tail call void @swift_unknownRelease(%swift.refcounted* %1)
+ tail call void @swift_release(%swift.refcounted* %1) nounwind
+ tail call %swift.refcounted* @swift_unknownRetain(%swift.refcounted* %P)
+ %3 = bitcast %swift.refcounted* %P to %swift.refcounted*
+ tail call void @swift_unknownRelease(%swift.refcounted* %3)
tail call %objc_object* @objc_retain(%objc_object* %O)
- %3 = bitcast %objc_object* %O to %objc_object*
- tail call void @objc_release(%objc_object* %3)
+ %5 = bitcast %objc_object* %O to %objc_object*
+ tail call void @objc_release(%objc_object* %5)
call void @user(%swift.refcounted* %P) nounwind
ret void
}
@@ -95,7 +95,7 @@
define void @retain_motion1(%swift.refcounted* %A) {
- tail call void @swift_retain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
%B = bitcast %swift.refcounted* %A to i32*
store i32 42, i32* %B
tail call void @swift_release(%swift.refcounted* %A) nounwind
@@ -122,7 +122,7 @@
define void @swiftunknown_retain_release_null() {
entry:
tail call void @swift_unknownRelease(%swift.refcounted* null)
- tail call void @swift_unknownRetain(%swift.refcounted* null) nounwind
+ tail call %swift.refcounted* @swift_unknownRetain(%swift.refcounted* null) nounwind
ret void
}
@@ -144,7 +144,7 @@
; CHECK: swift_fixLifetime
; CHECK: swift_release
define void @swift_fixLifetimeTest(%swift.refcounted* %A) {
- tail call void @swift_retain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
call void @user(%swift.refcounted* %A) nounwind
call void @__swift_fixLifetime(%swift.refcounted* %A)
tail call void @swift_release(%swift.refcounted* %A) nounwind
@@ -157,8 +157,8 @@
; CHECK-NOT: swift_release
; CHECK: ret
define void @move_retain_across_unknown_retain(%swift.refcounted* %A, %swift.refcounted* %B) {
- tail call void @swift_retain(%swift.refcounted* %A)
- tail call void @swift_unknownRetain(%swift.refcounted* %B)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_unknownRetain(%swift.refcounted* %B)
tail call void @swift_release(%swift.refcounted* %A) nounwind
ret void
}
@@ -169,7 +169,7 @@
; CHECK-NOT: swift_release
; CHECK: ret
define void @move_retain_across_objc_retain(%swift.refcounted* %A, %objc_object* %B) {
- tail call void @swift_retain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
tail call %objc_object* @objc_retain(%objc_object* %B)
tail call void @swift_release(%swift.refcounted* %A) nounwind
ret void
@@ -180,7 +180,7 @@
; CHECK-NOT: swift_release
; CHECK: ret
define i32 @move_retain_across_load(%swift.refcounted* %A, i32* %ptr) {
- tail call void @swift_retain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
%val = load i32, i32* %ptr
tail call void @swift_release(%swift.refcounted* %A) nounwind
ret i32 %val
@@ -188,13 +188,13 @@
; CHECK-LABEL: @move_retain_but_not_release_across_objc_fix_lifetime
; CHECK: call void @__swift_fixLifetime
-; CHECK-NEXT: tail call void @swift_retain
+; CHECK-NEXT: tail call %swift.refcounted* @swift_retain
; CHECK-NEXT: call void @user
; CHECK-NEXT: call void @__swift_fixLifetime
; CHECK-NEXT: call void @swift_release
; CHECK-NEXT: ret
define void @move_retain_but_not_release_across_objc_fix_lifetime(%swift.refcounted* %A) {
- tail call void @swift_retain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
call void @__swift_fixLifetime(%swift.refcounted* %A) nounwind
call void @user(%swift.refcounted* %A) nounwind
call void @__swift_fixLifetime(%swift.refcounted* %A) nounwind
@@ -210,7 +210,7 @@
; CHECK-NEXT: call void @swift_checkUnowned
; CHECK-NEXT: ret
define void @optimize_retain_unowned(%swift.refcounted* %A) {
- tail call void @swift_retainUnowned(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retainUnowned(%swift.refcounted* %A)
%value = bitcast %swift.refcounted* %A to i64*
; loads from the %A and speculatively executable instructions
@@ -223,14 +223,14 @@
}
; CHECK-LABEL: @dont_optimize_retain_unowned
-; CHECK-NEXT: call void @swift_retainUnowned
+; CHECK-NEXT: call %swift.refcounted* @swift_retainUnowned
; CHECK-NEXT: bitcast
; CHECK-NEXT: load
; CHECK-NEXT: load
; CHECK-NEXT: call void @swift_release
; CHECK-NEXT: ret
define void @dont_optimize_retain_unowned(%swift.refcounted* %A) {
- tail call void @swift_retainUnowned(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retainUnowned(%swift.refcounted* %A)
%value = bitcast %swift.refcounted* %A to i64**
%L1 = load i64*, i64** %value, align 8
@@ -242,12 +242,12 @@
}
; CHECK-LABEL: @dont_optimize_retain_unowned2
-; CHECK-NEXT: call void @swift_retainUnowned
+; CHECK-NEXT: call %swift.refcounted* @swift_retainUnowned
; CHECK-NEXT: store
; CHECK-NEXT: call void @swift_release
; CHECK-NEXT: ret
define void @dont_optimize_retain_unowned2(%swift.refcounted* %A, i32* %B) {
- tail call void @swift_retainUnowned(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retainUnowned(%swift.refcounted* %A)
; store to an unknown address
store i32 42, i32* %B
@@ -257,12 +257,12 @@
}
; CHECK-LABEL: @dont_optimize_retain_unowned3
-; CHECK-NEXT: call void @swift_retainUnowned
+; CHECK-NEXT: call %swift.refcounted* @swift_retainUnowned
; CHECK-NEXT: call void @unknown_func
; CHECK-NEXT: call void @swift_release
; CHECK-NEXT: ret
define void @dont_optimize_retain_unowned3(%swift.refcounted* %A) {
- tail call void @swift_retainUnowned(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retainUnowned(%swift.refcounted* %A)
; call of an unknown function
call void @unknown_func()
@@ -272,15 +272,15 @@
}
; CHECK-LABEL: @dont_optimize_retain_unowned4
-; CHECK-NEXT: call void @swift_retainUnowned
-; CHECK-NEXT: call void @swift_retain
+; CHECK-NEXT: call %swift.refcounted* @swift_retainUnowned
+; CHECK-NEXT: call %swift.refcounted* @swift_retain
; CHECK-NEXT: call void @swift_release
; CHECK-NEXT: ret
define void @dont_optimize_retain_unowned4(%swift.refcounted* %A, %swift.refcounted* %B) {
- tail call void @swift_retainUnowned(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retainUnowned(%swift.refcounted* %A)
; retain of an unknown reference (%B could be equal to %A)
- tail call void @swift_retain(%swift.refcounted* %B)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %B)
tail call void @swift_release(%swift.refcounted* %A)
ret void
@@ -295,7 +295,7 @@
; CHECK-NEXT: load
; CHECK-NEXT: ret
define void @remove_redundant_check_unowned(%swift.refcounted* %A, %swift.refcounted* %B, i64* %C) {
- tail call void @swift_retainUnowned(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retainUnowned(%swift.refcounted* %A)
%addr = bitcast %swift.refcounted* %A to i64*
%L1 = load i64, i64* %addr, align 8
tail call void @swift_release(%swift.refcounted* %A)
@@ -304,7 +304,7 @@
%L2 = load i64, i64* %C, align 8
store i64 42, i64* %C
- tail call void @swift_retainUnowned(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retainUnowned(%swift.refcounted* %A)
%L3 = load i64, i64* %addr, align 8
tail call void @swift_release(%swift.refcounted* %A)
ret void
@@ -319,7 +319,7 @@
; CHECK-NEXT: call void @swift_checkUnowned
; CHECK-NEXT: ret
define void @dont_remove_redundant_check_unowned(%swift.refcounted* %A, %swift.refcounted* %B, i64* %C) {
- tail call void @swift_retainUnowned(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retainUnowned(%swift.refcounted* %A)
%addr = bitcast %swift.refcounted* %A to i64*
%L1 = load i64, i64* %addr, align 8
tail call void @swift_release(%swift.refcounted* %A)
@@ -327,7 +327,7 @@
; Could do a release of %A
call void @unknown_func()
- tail call void @swift_retainUnowned(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retainUnowned(%swift.refcounted* %A)
%L3 = load i64, i64* %addr, align 8
tail call void @swift_release(%swift.refcounted* %A)
ret void
@@ -339,9 +339,9 @@
; CHECK-NEXT: swift_retain
; CHECK-NEXT: ret
define void @unknown_retain_promotion(%swift.refcounted* %A) {
- tail call void @swift_unknownRetain(%swift.refcounted* %A)
- tail call void @swift_unknownRetain(%swift.refcounted* %A)
- tail call void @swift_retain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_unknownRetain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_unknownRetain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
ret void
}
@@ -362,10 +362,10 @@
; CHECK-NOT: swift_retain
; CHECK: ret
define void @unknown_retain_nopromotion(%swift.refcounted* %A) {
- tail call void @swift_retain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
br label %bb1
bb1:
- tail call void @swift_unknownRetain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_unknownRetain(%swift.refcounted* %A)
ret void
}
diff --git a/test/LLVMPasses/contract.ll b/test/LLVMPasses/contract.ll
index 1e86a4f..3d643f2 100644
--- a/test/LLVMPasses/contract.ll
+++ b/test/LLVMPasses/contract.ll
@@ -7,11 +7,11 @@
%swift.heapmetadata = type { i64 (%swift.refcounted*)*, i64 (%swift.refcounted*)* }
%swift.bridge = type opaque
-declare %swift.refcounted* @swift_rt_swift_allocObject(%swift.heapmetadata* , i64, i64) nounwind
+declare %swift.refcounted* @swift_allocObject(%swift.heapmetadata* , i64, i64) nounwind
declare %swift.bridge* @swift_bridgeObjectRetain(%swift.bridge*)
declare void @swift_bridgeObjectRelease(%swift.bridge* )
-declare void @swift_rt_swift_release(%swift.refcounted* nocapture)
-declare %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* ) nounwind
+declare void @swift_release(%swift.refcounted* nocapture)
+declare %swift.refcounted* @swift_retain(%swift.refcounted* ) nounwind
declare void @swift_unknownRelease(%swift.refcounted* nocapture)
declare %swift.refcounted* @swift_unknownRetain(%swift.refcounted* ) nounwind
declare void @__swift_fixLifetime(%swift.refcounted*)
@@ -42,37 +42,37 @@
; CHECK: entry:
; CHECK-NEXT: br i1 undef
; CHECK: bb1:
-; CHECK-NEXT: tail call %swift.refcounted* @swift_rt_swift_retain_n(%swift.refcounted* %A, i32 2)
+; CHECK-NEXT: tail call %swift.refcounted* @swift_retain_n(%swift.refcounted* %A, i32 2)
; CHECK-NEXT: call void @noread_user(%swift.refcounted* %A)
; CHECK-NEXT: call void @noread_user(%swift.refcounted* %A)
; CHECK-NEXT: br label %bb3
; CHECK: bb2:
; CHECK-NEXT: call void @noread_user(%swift.refcounted* %A)
-; CHECK-NEXT: tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
+; CHECK-NEXT: tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
; CHECK-NEXT: call void @noread_user(%swift.refcounted* %A)
; CHECK-NEXT: br label %bb3
; CHECK: bb3:
-; CHECK-NEXT: tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
+; CHECK-NEXT: tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
; CHECK-NEXT: ret %swift.refcounted* %A
define %swift.refcounted* @swift_contractRetainN(%swift.refcounted* %A) {
entry:
br i1 undef, label %bb1, label %bb2
bb1:
- tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
call void @noread_user(%swift.refcounted* %A)
- tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
call void @noread_user(%swift.refcounted* %A)
br label %bb3
bb2:
call void @noread_user(%swift.refcounted* %A)
- tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
call void @noread_user(%swift.refcounted* %A)
br label %bb3
bb3:
- tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
ret %swift.refcounted* %A
}
@@ -80,31 +80,31 @@
; CHECK: entry:
; CHECK-NEXT: br i1 undef
; CHECK: bb1:
-; CHECK-NEXT: tail call %swift.refcounted* @swift_rt_swift_retain_n(%swift.refcounted* %A, i32 2)
+; CHECK-NEXT: tail call %swift.refcounted* @swift_retain_n(%swift.refcounted* %A, i32 2)
; CHECK-NEXT: %1 = bitcast %swift.refcounted* %A to %swift.refcounted*
; CHECK-NEXT: br label %bb3
; CHECK: bb2:
-; CHECK-NEXT: tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
+; CHECK-NEXT: tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
; CHECK-NEXT: br label %bb3
; CHECK: bb3:
-; CHECK-NEXT: tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
+; CHECK-NEXT: tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
; CHECK-NEXT: ret %swift.refcounted* %A
define %swift.refcounted* @swift_contractRetainNWithRCIdentity(%swift.refcounted* %A) {
entry:
br i1 undef, label %bb1, label %bb2
bb1:
- tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
%1 = bitcast %swift.refcounted* %A to %swift.refcounted*
- tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %1)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %1)
br label %bb3
bb2:
- tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
br label %bb3
bb3:
- tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
ret %swift.refcounted* %A
}
@@ -113,36 +113,36 @@
; CHECK-NEXT: br i1 undef
; CHECK: bb1:
; CHECK-NEXT: call void @noread_user(%swift.refcounted* %A)
-; CHECK-NEXT: tail call void @swift_rt_swift_release_n(%swift.refcounted* %A, i32 2)
+; CHECK-NEXT: tail call void @swift_release_n(%swift.refcounted* %A, i32 2)
; CHECK-NEXT: call void @noread_user(%swift.refcounted* %A)
; CHECK-NEXT: br label %bb3
; CHECK: bb2:
; CHECK-NEXT: call void @noread_user(%swift.refcounted* %A)
-; CHECK-NEXT: tail call void @swift_rt_swift_release(%swift.refcounted* %A)
+; CHECK-NEXT: tail call void @swift_release(%swift.refcounted* %A)
; CHECK-NEXT: call void @noread_user(%swift.refcounted* %A)
; CHECK-NEXT: br label %bb3
; CHECK: bb3:
-; CHECK-NEXT: tail call void @swift_rt_swift_release(%swift.refcounted* %A)
+; CHECK-NEXT: tail call void @swift_release(%swift.refcounted* %A)
; CHECK-NEXT: ret %swift.refcounted* %A
define %swift.refcounted* @swift_contractReleaseN(%swift.refcounted* %A) {
entry:
br i1 undef, label %bb1, label %bb2
bb1:
- tail call void @swift_rt_swift_release(%swift.refcounted* %A)
+ tail call void @swift_release(%swift.refcounted* %A)
call void @noread_user(%swift.refcounted* %A)
- tail call void @swift_rt_swift_release(%swift.refcounted* %A)
+ tail call void @swift_release(%swift.refcounted* %A)
call void @noread_user(%swift.refcounted* %A)
br label %bb3
bb2:
call void @noread_user(%swift.refcounted* %A)
- tail call void @swift_rt_swift_release(%swift.refcounted* %A)
+ tail call void @swift_release(%swift.refcounted* %A)
call void @noread_user(%swift.refcounted* %A)
br label %bb3
bb3:
- tail call void @swift_rt_swift_release(%swift.refcounted* %A)
+ tail call void @swift_release(%swift.refcounted* %A)
ret %swift.refcounted* %A
}
@@ -151,30 +151,30 @@
; CHECK-NEXT: br i1 undef
; CHECK: bb1:
; CHECK-NEXT: %0 = bitcast %swift.refcounted* %A to %swift.refcounted*
-; CHECK-NEXT: tail call void @swift_rt_swift_release_n(%swift.refcounted* %A, i32 2)
+; CHECK-NEXT: tail call void @swift_release_n(%swift.refcounted* %A, i32 2)
; CHECK-NEXT: br label %bb3
; CHECK: bb2:
-; CHECK-NEXT: tail call void @swift_rt_swift_release(%swift.refcounted* %A)
+; CHECK-NEXT: tail call void @swift_release(%swift.refcounted* %A)
; CHECK-NEXT: br label %bb3
; CHECK: bb3:
-; CHECK-NEXT: tail call void @swift_rt_swift_release(%swift.refcounted* %A)
+; CHECK-NEXT: tail call void @swift_release(%swift.refcounted* %A)
; CHECK-NEXT: ret %swift.refcounted* %A
define %swift.refcounted* @swift_contractReleaseNWithRCIdentity(%swift.refcounted* %A) {
entry:
br i1 undef, label %bb1, label %bb2
bb1:
- tail call void @swift_rt_swift_release(%swift.refcounted* %A)
+ tail call void @swift_release(%swift.refcounted* %A)
%0 = bitcast %swift.refcounted* %A to %swift.refcounted*
- tail call void @swift_rt_swift_release(%swift.refcounted* %0)
+ tail call void @swift_release(%swift.refcounted* %0)
br label %bb3
bb2:
- tail call void @swift_rt_swift_release(%swift.refcounted* %A)
+ tail call void @swift_release(%swift.refcounted* %A)
br label %bb3
bb3:
- tail call void @swift_rt_swift_release(%swift.refcounted* %A)
+ tail call void @swift_release(%swift.refcounted* %A)
ret %swift.refcounted* %A
}
@@ -183,112 +183,112 @@
; read the reference count of the object.
; CHECK-LABEL: define{{( protected)?}} %swift.refcounted* @swift_contractRetainNWithUnknown(%swift.refcounted* %A) {
-; CHECK-NOT: call %swift.refcounted* @swift_rt_swift_retain_n
+; CHECK-NOT: call %swift.refcounted* @swift_retain_n
define %swift.refcounted* @swift_contractRetainNWithUnknown(%swift.refcounted* %A) {
entry:
br i1 undef, label %bb1, label %bb2
bb1:
- tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
call void @user(%swift.refcounted* %A)
- tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
call void @user(%swift.refcounted* %A)
br label %bb3
bb2:
call void @user(%swift.refcounted* %A)
- tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
call void @user(%swift.refcounted* %A)
br label %bb3
bb3:
- tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
ret %swift.refcounted* %A
}
; CHECK-LABEL: define{{( protected)?}} %swift.refcounted* @swift_contractReleaseNWithUnknown(%swift.refcounted* %A) {
-; CHECK-NOT: call void @swift_rt_swift_release_n
+; CHECK-NOT: call void @swift_release_n
define %swift.refcounted* @swift_contractReleaseNWithUnknown(%swift.refcounted* %A) {
entry:
br i1 undef, label %bb1, label %bb2
bb1:
- tail call void @swift_rt_swift_release(%swift.refcounted* %A)
+ tail call void @swift_release(%swift.refcounted* %A)
call void @user(%swift.refcounted* %A)
- tail call void @swift_rt_swift_release(%swift.refcounted* %A)
+ tail call void @swift_release(%swift.refcounted* %A)
call void @user(%swift.refcounted* %A)
br label %bb3
bb2:
call void @user(%swift.refcounted* %A)
- tail call void @swift_rt_swift_release(%swift.refcounted* %A)
+ tail call void @swift_release(%swift.refcounted* %A)
call void @user(%swift.refcounted* %A)
br label %bb3
bb3:
- tail call void @swift_rt_swift_release(%swift.refcounted* %A)
+ tail call void @swift_release(%swift.refcounted* %A)
ret %swift.refcounted* %A
}
; But do make sure that we can form retainN, releaseN in between such uses
; CHECK-LABEL: define{{( protected)?}} %swift.refcounted* @swift_contractRetainNInterleavedWithUnknown(%swift.refcounted* %A) {
; CHECK: bb1:
-; CHECK: tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
+; CHECK: tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
; CHECK-NEXT: call void @user(%swift.refcounted* %A)
-; CHECK-NEXT: tail call %swift.refcounted* @swift_rt_swift_retain_n(%swift.refcounted* %A, i32 3)
+; CHECK-NEXT: tail call %swift.refcounted* @swift_retain_n(%swift.refcounted* %A, i32 3)
; CHECK-NEXT: call void @noread_user(%swift.refcounted* %A)
; CHECK-NEXT: call void @noread_user(%swift.refcounted* %A)
; CHECK-NEXT: call void @user(%swift.refcounted* %A)
-; CHECK-NEXT: tail call %swift.refcounted* @swift_rt_swift_retain_n(%swift.refcounted* %A, i32 2)
+; CHECK-NEXT: tail call %swift.refcounted* @swift_retain_n(%swift.refcounted* %A, i32 2)
; CHECK-NEXT: call void @user(%swift.refcounted* %A)
-; CHECK-NEXT: tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
+; CHECK-NEXT: tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
; CHECK-NEXT: br label %bb3
; CHECK: bb2:
; CHECK-NEXT: call void @user(%swift.refcounted* %A)
-; CHECK-NEXT: tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
+; CHECK-NEXT: tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
; CHECK-NEXT: call void @user(%swift.refcounted* %A)
; CHECK-NEXT: br label %bb3
; CHECK: bb3:
-; CHECK-NEXT: tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
+; CHECK-NEXT: tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
; CHECK-NEXT: ret %swift.refcounted* %A
define %swift.refcounted* @swift_contractRetainNInterleavedWithUnknown(%swift.refcounted* %A) {
entry:
br i1 undef, label %bb1, label %bb2
bb1:
- tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
call void @user(%swift.refcounted* %A)
- tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
call void @noread_user(%swift.refcounted* %A)
- tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
call void @noread_user(%swift.refcounted* %A)
- tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
call void @user(%swift.refcounted* %A)
- tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
- tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
call void @user(%swift.refcounted* %A)
- tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
br label %bb3
bb2:
call void @user(%swift.refcounted* %A)
- tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
call void @user(%swift.refcounted* %A)
br label %bb3
bb3:
- tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
ret %swift.refcounted* %A
}
; CHECK-LABEL: define{{( protected)?}} %swift.refcounted* @swift_contractReleaseNInterleavedWithUnknown(%swift.refcounted* %A) {
; CHECK: bb1:
-; CHECK-NEXT: @swift_rt_swift_release(
+; CHECK-NEXT: @swift_release(
; CHECK-NEXT: @user
; CHECK-NEXT: @noread_user
-; CHECK-NEXT: @swift_rt_swift_release_n
+; CHECK-NEXT: @swift_release_n
; CHECK-NEXT: @user
; CHECK-NEXT: br label %bb3
define %swift.refcounted* @swift_contractReleaseNInterleavedWithUnknown(%swift.refcounted* %A) {
@@ -296,78 +296,78 @@
br i1 undef, label %bb1, label %bb2
bb1:
- tail call void @swift_rt_swift_release(%swift.refcounted* %A)
+ tail call void @swift_release(%swift.refcounted* %A)
call void @user(%swift.refcounted* %A)
- tail call void @swift_rt_swift_release(%swift.refcounted* %A)
+ tail call void @swift_release(%swift.refcounted* %A)
call void @noread_user(%swift.refcounted* %A)
- tail call void @swift_rt_swift_release(%swift.refcounted* %A)
+ tail call void @swift_release(%swift.refcounted* %A)
call void @user(%swift.refcounted* %A)
br label %bb3
bb2:
call void @user(%swift.refcounted* %A)
- tail call void @swift_rt_swift_release(%swift.refcounted* %A)
+ tail call void @swift_release(%swift.refcounted* %A)
call void @user(%swift.refcounted* %A)
br label %bb3
bb3:
- tail call void @swift_rt_swift_release(%swift.refcounted* %A)
+ tail call void @swift_release(%swift.refcounted* %A)
ret %swift.refcounted* %A
}
; CHECK-LABEL: define{{( protected)?}} %swift.refcounted* @swift_contractRetainReleaseNInterleavedWithUnknown(%swift.refcounted* %A) {
; CHECK: bb1:
-; CHECK-NEXT: tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
+; CHECK-NEXT: tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
; CHECK-NEXT: call void @user(%swift.refcounted* %A)
; CHECK-NEXT: call void @noread_user(%swift.refcounted* %A)
-; CHECK-NEXT: tail call void @swift_rt_swift_release_n(%swift.refcounted* %A, i32 2)
+; CHECK-NEXT: tail call void @swift_release_n(%swift.refcounted* %A, i32 2)
; CHECK-NEXT: call void @user(%swift.refcounted* %A)
-; CHECK-NEXT: tail call %swift.refcounted* @swift_rt_swift_retain_n(%swift.refcounted* %A, i32 2)
-; CHECK-NEXT: tail call void @swift_rt_swift_release(%swift.refcounted* %A)
+; CHECK-NEXT: tail call %swift.refcounted* @swift_retain_n(%swift.refcounted* %A, i32 2)
+; CHECK-NEXT: tail call void @swift_release(%swift.refcounted* %A)
; CHECK-NEXT: call void @user(%swift.refcounted* %A)
; CHECK-NEXT: call void @noread_user(%swift.refcounted* %A)
-; CHECK-NEXT: tail call void @swift_rt_swift_release_n(%swift.refcounted* %A, i32 2)
+; CHECK-NEXT: tail call void @swift_release_n(%swift.refcounted* %A, i32 2)
; CHECK-NEXT: call void @user(%swift.refcounted* %A)
; CHECK-NEXT: br label %bb3
; CHECK: bb2:
; CHECK-NEXT: call void @user(%swift.refcounted* %A)
-; CHECK-NEXT: call void @swift_rt_swift_release(%swift.refcounted* %A)
+; CHECK-NEXT: call void @swift_release(%swift.refcounted* %A)
; CHECK-NEXT: call void @user(%swift.refcounted* %A)
; CHECK-NEXT: br label %bb3
; CHECK: bb3:
-; CHECK-NEXT: tail call void @swift_rt_swift_release(%swift.refcounted* %A)
+; CHECK-NEXT: tail call void @swift_release(%swift.refcounted* %A)
; CHECK-NEXT: ret %swift.refcounted* %A
define %swift.refcounted* @swift_contractRetainReleaseNInterleavedWithUnknown(%swift.refcounted* %A) {
entry:
br i1 undef, label %bb1, label %bb2
bb1:
- tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
call void @user(%swift.refcounted* %A)
- tail call void @swift_rt_swift_release(%swift.refcounted* %A)
+ tail call void @swift_release(%swift.refcounted* %A)
call void @noread_user(%swift.refcounted* %A)
- tail call void @swift_rt_swift_release(%swift.refcounted* %A)
+ tail call void @swift_release(%swift.refcounted* %A)
call void @user(%swift.refcounted* %A)
- tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
- tail call %swift.refcounted* @swift_rt_swift_retain(%swift.refcounted* %A)
- tail call void @swift_rt_swift_release(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
+ tail call %swift.refcounted* @swift_retain(%swift.refcounted* %A)
+ tail call void @swift_release(%swift.refcounted* %A)
call void @user(%swift.refcounted* %A)
- tail call void @swift_rt_swift_release(%swift.refcounted* %A)
+ tail call void @swift_release(%swift.refcounted* %A)
call void @noread_user(%swift.refcounted* %A)
- tail call void @swift_rt_swift_release(%swift.refcounted* %A)
+ tail call void @swift_release(%swift.refcounted* %A)
call void @user(%swift.refcounted* %A)
br label %bb3
bb2:
call void @user(%swift.refcounted* %A)
- tail call void @swift_rt_swift_release(%swift.refcounted* %A)
+ tail call void @swift_release(%swift.refcounted* %A)
call void @user(%swift.refcounted* %A)
br label %bb3
bb3:
- tail call void @swift_rt_swift_release(%swift.refcounted* %A)
+ tail call void @swift_release(%swift.refcounted* %A)
ret %swift.refcounted* %A
}
diff --git a/test/SIL/Parser/indirect_enum.sil b/test/SIL/Parser/indirect_enum.sil
index f550c84..f83ed00 100644
--- a/test/SIL/Parser/indirect_enum.sil
+++ b/test/SIL/Parser/indirect_enum.sil
@@ -27,7 +27,7 @@
%b = project_box %a : $<τ_0_0> { var τ_0_0 } <T>, 0
%c = unchecked_enum_data %e : $TreeA<T>, #TreeA.Branch!enumelt.1
- %d = project_box %c : $<τ_0_0> { var τ_0_0 } <(left: TreeA<T>, right: TreeA<T>)>, 0
+ %d = project_box %c : $<τ_0_0> { var (left: TreeA<τ_0_0>, right: TreeA<τ_0_0>) } <T>, 0
return undef : $()
}
@@ -38,7 +38,7 @@
destroy_addr %a : $*T
%c = unchecked_take_enum_data_addr %e : $*TreeB<T>, #TreeB.Branch!enumelt.1
- %d = load [take] %c : $*<τ_0_0> { var τ_0_0 } <(left: TreeB<T>, right: TreeB<T>)>
+ %d = load [take] %c : $*<τ_0_0> { var (left: TreeB<τ_0_0>, right: TreeB<τ_0_0>) } <T>
return undef : $()
}
@@ -49,7 +49,7 @@
store %a to [trivial] undef : $*Int
%c = unchecked_enum_data %e : $TreeInt, #TreeInt.Branch!enumelt.1
- %d = project_box %c : $<τ_0_0> { var τ_0_0 } <(left: TreeInt, right: TreeInt)>, 0
+ %d = project_box %c : ${ var (left: TreeInt, right: TreeInt) }, 0
return undef : $()
}
diff --git a/test/SILGen/enum.swift b/test/SILGen/enum.swift
index 0134f45..af87a52 100644
--- a/test/SILGen/enum.swift
+++ b/test/SILGen/enum.swift
@@ -190,3 +190,14 @@
func Foo_cases() {
_ = Foo.A
}
+
+enum Indirect<T> {
+ indirect case payload((T, other: T))
+ case none
+}
+// CHECK-LABEL: sil{{.*}} @{{.*}}makeIndirectEnum{{.*}} : $@convention(thin) <T> (@in T) -> @owned Indirect<T>
+// CHECK: [[BOX:%.*]] = alloc_box $<τ_0_0> { var (τ_0_0, other: τ_0_0) } <T>
+// CHECK: enum $Indirect<T>, #Indirect.payload!enumelt.1, [[BOX]] : $<τ_0_0> { var (τ_0_0, other: τ_0_0) } <T>
+func makeIndirectEnum<T>(_ payload: T) -> Indirect<T> {
+ return Indirect.payload((payload, other: payload))
+}
diff --git a/test/SILGen/indirect_enum.swift b/test/SILGen/indirect_enum.swift
index 0f5d9a0..bae2be1 100644
--- a/test/SILGen/indirect_enum.swift
+++ b/test/SILGen/indirect_enum.swift
@@ -23,7 +23,7 @@
let _ = TreeA<T>.Leaf(t)
// CHECK-NEXT: [[METATYPE:%.*]] = metatype $@thin TreeA<T>.Type
-// CHECK-NEXT: [[BOX:%.*]] = alloc_box $<τ_0_0> { var τ_0_0 } <(left: TreeA<T>, right: TreeA<T>)>
+// CHECK-NEXT: [[BOX:%.*]] = alloc_box $<τ_0_0> { var (left: TreeA<τ_0_0>, right: TreeA<τ_0_0>) } <T>
// CHECK-NEXT: [[PB:%.*]] = project_box [[BOX]]
// CHECK-NEXT: [[LEFT:%.*]] = tuple_element_addr [[PB]] : $*(left: TreeA<T>, right: TreeA<T>), 0
// CHECK-NEXT: [[RIGHT:%.*]] = tuple_element_addr [[PB]] : $*(left: TreeA<T>, right: TreeA<T>), 1
@@ -50,7 +50,7 @@
func TreeA_reabstract(_ f: @escaping (Int) -> Int) {
// CHECK: bb0([[ARG:%.*]] : $@callee_guaranteed (Int) -> Int):
// CHECK: [[METATYPE:%.*]] = metatype $@thin TreeA<(Int) -> Int>.Type
-// CHECK-NEXT: [[BOX:%.*]] = alloc_box $<τ_0_0> { var τ_0_0 } <@callee_guaranteed (@in Int) -> @out Int>
+// CHECK-NEXT: [[BOX:%.*]] = alloc_box $<τ_0_0> { var τ_0_0 } <(Int) -> Int>
// CHECK-NEXT: [[PB:%.*]] = project_box [[BOX]]
// CHECK-NEXT: [[BORROWED_ARG:%.*]] = begin_borrow [[ARG]]
// CHECK-NEXT: [[ARG_COPY:%.*]] = copy_value [[BORROWED_ARG]]
@@ -92,7 +92,7 @@
let _ = TreeB<T>.Leaf(t)
// CHECK-NEXT: [[METATYPE:%.*]] = metatype $@thin TreeB<T>.Type
-// CHECK-NEXT: [[BOX:%.*]] = alloc_box $<τ_0_0> { var τ_0_0 } <(left: TreeB<T>, right: TreeB<T>)>
+// CHECK-NEXT: [[BOX:%.*]] = alloc_box $<τ_0_0> { var (left: TreeB<τ_0_0>, right: TreeB<τ_0_0>) } <T>
// CHECK-NEXT: [[PB:%.*]] = project_box [[BOX]]
// CHECK-NEXT: [[LEFT:%.*]] = tuple_element_addr [[PB]]
// CHECK-NEXT: [[RIGHT:%.*]] = tuple_element_addr [[PB]]
@@ -127,7 +127,7 @@
let _ = TreeInt.Leaf(t)
// CHECK-NEXT: [[METATYPE:%.*]] = metatype $@thin TreeInt.Type
-// CHECK-NEXT: [[BOX:%.*]] = alloc_box $<τ_0_0> { var τ_0_0 } <(left: TreeInt, right: TreeInt)>
+// CHECK-NEXT: [[BOX:%.*]] = alloc_box ${ var (left: TreeInt, right: TreeInt) }
// CHECK-NEXT: [[PB:%.*]] = project_box [[BOX]]
// CHECK-NEXT: [[LEFT:%.*]] = tuple_element_addr [[PB]]
// CHECK-NEXT: [[RIGHT:%.*]] = tuple_element_addr [[PB]]
@@ -194,7 +194,7 @@
case .Leaf(let x):
b(x)
- // CHECK: [[BRANCH_CASE]]([[NODE_BOX:%.*]] : $<τ_0_0> { var τ_0_0 } <(left: TreeA<T>, right: TreeA<T>)>):
+ // CHECK: [[BRANCH_CASE]]([[NODE_BOX:%.*]] : $<τ_0_0> { var (left: TreeA<τ_0_0>, right: TreeA<τ_0_0>) } <T>):
// CHECK: [[TUPLE_ADDR:%.*]] = project_box [[NODE_BOX]]
// CHECK: [[TUPLE:%.*]] = load_borrow [[TUPLE_ADDR]]
// CHECK: [[LEFT:%.*]] = tuple_extract [[TUPLE]] {{.*}}, 0
@@ -370,7 +370,7 @@
// CHECK: [[NO]]([[ORIGINAL_VALUE:%.*]] : $TreeA<T>):
// CHECK: destroy_value [[ORIGINAL_VALUE]]
// CHECK: end_borrow [[BORROWED_ARG_3]] from [[ARG]]
- // CHECK: [[YES]]([[BOX:%.*]] : $<τ_0_0> { var τ_0_0 } <(left: TreeA<T>, right: TreeA<T>)>):
+ // CHECK: [[YES]]([[BOX:%.*]] : $<τ_0_0> { var (left: TreeA<τ_0_0>, right: TreeA<τ_0_0>) } <T>):
// CHECK: [[VALUE_ADDR:%.*]] = project_box [[BOX]]
// CHECK: [[TUPLE:%.*]] = load [take] [[VALUE_ADDR]]
// CHECK: [[TUPLE_COPY:%.*]] = copy_value [[TUPLE]]
@@ -425,7 +425,7 @@
// CHECK: [[NO]]([[ORIGINAL_VALUE:%.*]] : $TreeA<T>):
// CHECK: destroy_value [[ORIGINAL_VALUE]]
// CHECK: end_borrow [[BORROWED_ARG]] from [[ARG]]
- // CHECK: [[YES]]([[BOX:%.*]] : $<τ_0_0> { var τ_0_0 } <(left: TreeA<T>, right: TreeA<T>)>):
+ // CHECK: [[YES]]([[BOX:%.*]] : $<τ_0_0> { var (left: TreeA<τ_0_0>, right: TreeA<τ_0_0>) } <T>):
// CHECK: [[VALUE_ADDR:%.*]] = project_box [[BOX]]
// CHECK: [[TUPLE:%.*]] = load [take] [[VALUE_ADDR]]
// CHECK: [[TUPLE_COPY:%.*]] = copy_value [[TUPLE]]
@@ -540,7 +540,7 @@
// CHECK: [[ARG_COPY:%.*]] = copy_value [[BORROWED_ARG]]
// CHECK: switch_enum [[ARG_COPY]] : $TrivialButIndirect, case #TrivialButIndirect.Direct!enumelt.1: [[YES:bb[0-9]+]], case #TrivialButIndirect.Indirect!enumelt.1: [[NO:bb[0-9]+]]
//
- // CHECK: [[NO]]([[PAYLOAD:%.*]] : $<τ_0_0> { var τ_0_0 } <Int>):
+ // CHECK: [[NO]]([[PAYLOAD:%.*]] : ${ var Int }):
// CHECK: destroy_value [[PAYLOAD]]
// CHECK: end_borrow [[BORROWED_ARG]] from [[ARG]]
guard case .Direct(let foo) = x else { return }
@@ -555,7 +555,7 @@
// CHECK-NOT: destroy_value
// CHECK: end_borrow [[BORROWED_ARG]] from [[ARG]]
- // CHECK: [[YES]]([[BOX:%.*]] : $<τ_0_0> { var τ_0_0 } <Int>):
+ // CHECK: [[YES]]([[BOX:%.*]] : ${ var Int }):
// CHECK: destroy_value [[BOX]]
guard case .Indirect(let bar) = x else { return }
diff --git a/test/SILOptimizer/predictable_memopt.sil b/test/SILOptimizer/predictable_memopt.sil
index 75ffb68..5972ecb 100644
--- a/test/SILOptimizer/predictable_memopt.sil
+++ b/test/SILOptimizer/predictable_memopt.sil
@@ -436,14 +436,14 @@
sil @indirect_enum_box : $@convention(thin) (Int) -> IndirectCase {
// CHECK: bb0([[X:%.*]] : $Int):
entry(%x : $Int):
- // CHECK: [[BOX:%.*]] = alloc_box $<τ_0_0> { var τ_0_0 } <Int>
- %b = alloc_box $<τ_0_0> { var τ_0_0 } <Int>
+ // CHECK: [[BOX:%.*]] = alloc_box ${ var Int }
+ %b = alloc_box ${ var Int }
// CHECK: [[PB:%.*]] = project_box [[BOX]]
- %ba = project_box %b : $<τ_0_0> { var τ_0_0 } <Int>, 0
+ %ba = project_box %b : ${ var Int }, 0
// CHECK: store [[X]] to [[PB]]
store %x to %ba : $*Int
- // CHECK: [[E:%.*]] = enum $IndirectCase, #IndirectCase.X!enumelt.1, [[BOX]] : $<τ_0_0> { var τ_0_0 } <Int>
- %e = enum $IndirectCase, #IndirectCase.X!enumelt.1, %b : $<τ_0_0> { var τ_0_0 } <Int>
+ // CHECK: [[E:%.*]] = enum $IndirectCase, #IndirectCase.X!enumelt.1, [[BOX]] : ${ var Int }
+ %e = enum $IndirectCase, #IndirectCase.X!enumelt.1, %b : ${ var Int }
// CHECK: return [[E]]
return %e : $IndirectCase
}
@@ -837,4 +837,4 @@
bb2:
destroy_addr %1 : $*Builtin.NativeObject
unreachable
-}
\ No newline at end of file
+}
diff --git a/test/lit.site.cfg.in b/test/lit.site.cfg.in
index fb351a1..b8b05ea 100644
--- a/test/lit.site.cfg.in
+++ b/test/lit.site.cfg.in
@@ -74,6 +74,9 @@
if "@SWIFT_HAVE_WORKING_STD_REGEX@" == "FALSE":
config.available_features.add('broken_std_regex')
+if "@SWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS@" == "TRUE":
+ config.available_features.add('runtime_function_counters')
+
if "@CMAKE_GENERATOR@" == "Xcode":
xcode_bin_dir = os.path.join(config.llvm_obj_root, "@LLVM_BUILD_TYPE@",
'bin')
diff --git a/test/stdlib/BridgedObjectDebuggerSupport.swift b/test/stdlib/BridgedObjectDebuggerSupport.swift
new file mode 100644
index 0000000..a1950f5
--- /dev/null
+++ b/test/stdlib/BridgedObjectDebuggerSupport.swift
@@ -0,0 +1,98 @@
+// RUN: %target-run-simple-swift
+// REQUIRES: executable_test, objc_interop
+
+import Foundation
+import StdlibUnittest
+
+let StringForPrintObjectTests = TestSuite("StringForPrintObject")
+
+// Wrap stringForPrintObject for convenience. Note that the debugger uses
+// something slightly different to pretty-print (see: debugVal()).
+func printObj<T>(_ x: T) -> String {
+ return _DebuggerSupport.stringForPrintObject(x)
+}
+
+// Check if @x has a reference type.
+func hasReferenceType<T>(_ x: T) -> Bool {
+ return _canBeClass(T.self) == 1
+}
+
+// The debugger uses unsafeBitCast to take an arbitrary address and cast it to
+// AnyObject. Mimic that operation here.
+func debugVal<T>(_ x: inout T) -> String {
+ if !hasReferenceType(x) {
+ return printObj(x)
+ }
+ return withUnsafePointer(to: &x) {
+ return _DebuggerSupport.stringForPrintObject(Swift.unsafeBitCast($0.pointee, to: AnyObject.self))
+ }
+}
+
+StringForPrintObjectTests.test("Basic") {
+ var a = "Hello World" as NSString
+ let a_printed = printObj(a)
+ let a_debug = debugVal(&a)
+ expectEqual("Hello World", String(reflecting: a))
+ expectEqual("Hello World\n", a_printed)
+ expectEqual(a_printed, a_debug)
+}
+
+StringForPrintObjectTests.test("NSStringFromStringLiteral") {
+ var a = Foundation.NSString(stringLiteral: "Hello World")
+ let a_printed = printObj(a)
+ let a_debug = debugVal(&a)
+ expectEqual("Hello World", String(reflecting: a))
+ expectEqual("Hello World\n", a_printed)
+ expectEqual(a_printed, a_debug)
+}
+
+StringForPrintObjectTests.test("NSStringFromUnsafeBuffer") {
+ let buf = UnsafeMutablePointer<Int8>.allocate(capacity: 8)
+ buf[0] = 65
+ buf[1] = 0
+ var a = Foundation.NSString(utf8String: buf)!
+ let a_printed = printObj(a)
+ let a_debug = debugVal(&a)
+ expectEqual("A", String(reflecting: a))
+ expectEqual("A\n", a_printed)
+ expectEqual(a_printed, a_debug)
+ buf.deallocate()
+}
+
+StringForPrintObjectTests.test("ArrayOfStrings") {
+ var a = ["Hello World" as NSString]
+ let a_printed = printObj(a)
+ let a_debug = debugVal(&a)
+ expectEqual("[Hello World]", String(reflecting: a))
+ expectEqual("▿ 1 element\n - 0 : Hello World\n", a_printed)
+ expectEqual(a_printed, a_debug)
+}
+
+struct StructWithOneMember {
+ var a = "Hello World" as NSString
+}
+
+StringForPrintObjectTests.test("StructWithOneMember") {
+ var a = StructWithOneMember()
+ let a_printed = printObj(StructWithOneMember())
+ let a_debug = debugVal(&a)
+ expectEqual("main.StructWithOneMember(a: Hello World)", String(reflecting: a))
+ expectEqual("▿ StructWithOneMember\n - a : Hello World\n", a_printed)
+ expectEqual(a_printed, a_debug)
+}
+
+struct StructWithTwoMembers {
+ var a = 1
+ var b = "Hello World" as NSString
+}
+
+StringForPrintObjectTests.test("StructWithTwoMembers") {
+ var a = StructWithTwoMembers()
+ let a_printed = printObj(StructWithTwoMembers())
+ let a_debug = debugVal(&a)
+ expectEqual("main.StructWithTwoMembers(a: 1, b: Hello World)", String(reflecting: a))
+ expectEqual("▿ StructWithTwoMembers\n - a : 1\n - b : Hello World\n", a_printed)
+ expectEqual(a_printed, a_debug)
+}
+
+runAllTests()
diff --git a/test/stdlib/test_runtime_function_counters.swift b/test/stdlib/test_runtime_function_counters.swift
index c6a202f..4d17e45 100644
--- a/test/stdlib/test_runtime_function_counters.swift
+++ b/test/stdlib/test_runtime_function_counters.swift
@@ -1,7 +1,7 @@
// RUN: %empty-directory(%t)
// RUN: %target-build-swift %s -o %t/test_runtime_function_counters
// RUN: %target-run %t/test_runtime_function_counters 2>&1 | %FileCheck %s
-// REQUIRES: swift_stdlib_asserts
+// REQUIRES: runtime_function_counters
// REQUIRES: executable_test
/// Test functionality related to the runtime function counters.
diff --git a/test/stdlib/test_runtime_function_counters_with_disabled_assertions.swift b/test/stdlib/test_runtime_function_counters_with_disabled_assertions.swift
deleted file mode 100644
index 2fdd58b..0000000
--- a/test/stdlib/test_runtime_function_counters_with_disabled_assertions.swift
+++ /dev/null
@@ -1,273 +0,0 @@
-// RUN: %empty-directory(%t)
-// RUN: %target-build-swift %s -o %t/test_runtime_function_counters
-// RUN: %target-run %t/test_runtime_function_counters 2>&1 | %FileCheck %s
-// REQUIRES: executable_test
-
-/// Test functionality related to the runtime function counters.
-
-class C {
- var next: C? = nil
- func test(_ c: C) {
- }
-}
-
-struct MyStruct {
- var ref1: AnyObject? = C()
- var ref2: AnyObject = C()
- var str: String = ""
-}
-
-public final class List<T> {
- var value: T
- var next: List<T>?
-
- init(_ value: T) {
- self.value = value
- self.next = nil
- }
-
- init(_ value: T, _ tail: List<T>) {
- self.value = value
- self.next = tail
- }
-}
-
-public func length<T>(_ l: List<T>) -> Int {
- var ll: List<T>? = l
- var len = 0
- while ll != nil {
- len = len + 1
- ll = ll?.next
- }
- return len
-}
-
-/// CHECK-LABEL: TEST: Collect references inside objects
-
-// Constant strings don't really have a reference, but BridgeObject
-// still counts as one.
-//
-// FIXME(TODO: JIRA): On 32-bit, we use AnyObject? instead of BridgeObject. If
-// we get back onto a real reference (or if 64-bit gets off of a real
-// reference), then drop adjust the optionality of the following check.
-//
-/// CHECK: Constant string: [{{([0-9a-fA-Fx]+)?}}]
-
-/// An array has one reference
-/// CHECK: Array<Int>: [{{[0-9a-fA-Fx]+}}]
-
-/// MyStruct has two references plus a String with a third
-//
-// FIXME(TODO: JIRA): On 32-bit, we use AnyObject? instead of BridgeObject. If
-// we get back onto a real reference (or if 64-bit gets off of a real
-// reference), then drop adjust the optionality of the following check.
-//
-/// CHECK: MyStruct: [{{[0-9a-fA-Fx]+}}, {{[0-9a-fA-Fx]+}}{{(, [0-9a-fA-Fx]+)?}}]
-
-/// Dictionary has one reference
-/// CHECK: Dictionary<Int, Int>: [{{[0-9a-fA-Fx]+}}]
-/// Set has one reference
-/// CHECK: Set<Int>: [{{[0-9a-fA-Fx]+}}]
-/// Test collection of references inside different types of objects.
-@inline(never)
-func testCollectReferencesInsideObject() {
- print("TEST: Collect references inside objects")
- let s = "MyString"
- let aint = [1,2,3,4]
- let dint = [1:1, 2:2]
- let sint: Set<Int> = [1,2,3,4]
-
- print("Constant string: \(_collectReferencesInsideObject(s))")
- print("Array<Int>: \(_collectReferencesInsideObject(aint))")
- print("MyStruct: \(_collectReferencesInsideObject(MyStruct()))")
- print("Dictionary<Int, Int>: \(_collectReferencesInsideObject(dint))")
- print("Set<Int>: \(_collectReferencesInsideObject(sint))")
-
- var mystring = "MyString"
- mystring.append("End")
- testString(mystring)
- testDict(dint)
- testObjectCycle()
-}
-
-
-/// CHECK-LABEL: TEST: APIs from _RuntimeFunctionCounters
-/// CHECK: Number of runtime function pointers:
-/// Test some APIs from _RuntimeFunctionCounters
-func testRuntimeCounters() {
- print("TEST: APIs from _RuntimeFunctionCounters")
- let numRuntimeFunctionPointer =
- _RuntimeFunctionCounters.getNumRuntimeFunctionCounters()
-
- print("Number of runtime function pointers: \(numRuntimeFunctionPointer)")
-
- let names = _RuntimeFunctionCounters.getRuntimeFunctionNames()
- let offsets = _RuntimeFunctionCounters.getRuntimeFunctionCountersOffsets()
-
- for i in 0..<numRuntimeFunctionPointer {
- print("Runtime function \(i) : \(names[i]) at offset: \(offsets[i])")
- }
-
- var d: [Int : Int] = [:]
- let globalCounters1 = _GlobalRuntimeFunctionCountersState()
-
- for i in 0..<50 {
- let k = i
- let v = i*i
- d[k] = v
- }
-
- let globalCounters2 = _GlobalRuntimeFunctionCountersState()
-
- globalCounters1.dumpDiff(globalCounters2, skipUnchanged: true)
-}
-
-/// Test finding references inside a String object.
-@inline(never)
-func testString(_ s: String) {
- print("TEST: Collect references for strings")
- let refs = _collectReferencesInsideObject(s)
- print("References are: \(refs)")
- let objectCounters1 = _ObjectRuntimeFunctionCountersState(refs[0])
- let _ = [String](repeating: s, count: 4)
- let objectCounters2 = _ObjectRuntimeFunctionCountersState(refs[0])
- objectCounters1.dumpDiff(objectCounters2, skipUnchanged: true)
-}
-
-/// Test finding references inside a Dictionary object.
-@inline(never)
-func testDict(_ _dint: [Int : Int]) {
- print("TEST: Collect references for dictionaries")
- var dint = _dint
- dint[3] = 3
- let refs = _collectReferencesInsideObject(dint)
- print("References are: \(refs)")
- let objectCounters1 = _ObjectRuntimeFunctionCountersState(refs[0])
- dint[222] = 222
- dint[2222] = 2222
- let objectCounters2 = _ObjectRuntimeFunctionCountersState(refs[0])
- objectCounters1.dumpDiff(objectCounters2, skipUnchanged: true)
-}
-
-/// Test finding references inside an object graph with a cycle.
-/// It should not result in a stack overflow.
-@inline(never)
-func testObjectCycle() {
- print("TEST: Collect references on object graph with cycles")
- print("testObjectCycle")
- let c1 = C()
- let c2 = C()
- c1.next = c1
- c2.next = c1
- let refs = _collectReferencesInsideObject(c1)
- print("References are: \(refs)")
- let objectCounters1 = _ObjectRuntimeFunctionCountersState(refs[0])
- c1.next = nil
- c2.next = nil
- let objectCounters2 = _ObjectRuntimeFunctionCountersState(refs[0])
- objectCounters1.dumpDiff(objectCounters2, skipUnchanged: true)
-}
-
-/// Test runtime function counters for a List object.
-@inline(never)
-func testLists() {
- print("TEST: Runtime function counters for Lists")
- print("testLists")
- let globalCounters1 = _GlobalRuntimeFunctionCountersState()
- var l: List<Int>? = List(1, List(2, List(3, List(4, List(5)))))
- let refs = _collectReferencesInsideObject(l!)
- let globalCounters11 = _GlobalRuntimeFunctionCountersState()
- let _ = _collectReferencesInsideObject(l!)
- let globalCounters111 = _GlobalRuntimeFunctionCountersState()
-
- print("Global counters diff for 11")
- globalCounters1.dumpDiff(globalCounters11, skipUnchanged: true)
- print("Global counters diff for 111")
- globalCounters1.dumpDiff(globalCounters111, skipUnchanged: true)
-
- let len = length(l!)
- let globalCounters2 = _GlobalRuntimeFunctionCountersState()
- print("Length of the list is \(len)")
- print("Global counters diff after constructing a list and computing its length")
- globalCounters1.dumpDiff(globalCounters2, skipUnchanged: true)
- let objectCounters1 = _ObjectRuntimeFunctionCountersState(refs[0])
- l = nil
- let objectCounters2 = _ObjectRuntimeFunctionCountersState(refs[0])
- print("List head counters after list becomes unreferenced")
- objectCounters1.dumpDiff(objectCounters2, skipUnchanged: true)
-}
-
-/// Test the _measureRuntimeFunctionCountersDiffs API.
-@inline(never)
-func testMeasureRuntimeFunctionCountersDiffs() {
- print("TEST: Measure runtime function counters diff")
- let l: List<Int>? = List(1, List(2, List(3, List(4, List(5)))))
- let refs = _collectReferencesInsideObject(l!)
- var len = 0
- let (globalCounters, objectsCountersDiffs) =
- _measureRuntimeFunctionCountersDiffs(objects: [refs[0]]) {
- len = length(l!)
- }
- print("List length is: \(len)")
- print("Global counters changes")
- globalCounters.dump(skipUnchanged: true)
- print("Objects counters changes")
- for (i, objectCounters) in objectsCountersDiffs.enumerated() {
- print("Object counters diff for \(refs[i])")
- objectCounters.dump(skipUnchanged: true)
- }
-}
-
-/// This is a handler that is invoked on each runtime functions counters update.
-@inline(never)
-func updatesHandler(object: UnsafeRawPointer, functionId: Int64) {
- let savedMode = _RuntimeFunctionCounters.disableRuntimeFunctionCountersUpdates()
- print("Start handler")
- let functionName = _RuntimeFunctionCounters.runtimeFunctionNames[Int(functionId)]
- print("Function \(functionName) was invoked on object \(object)")
- print("End handler")
- _RuntimeFunctionCounters.enableRuntimeFunctionCountersUpdates(mode: savedMode)
-}
-
-/// Check that it is possible to set your own runtime functions counters
-/// updates handler and this handler is invoked at runtime.
-/// CHECK-LABEL: TEST: Provide runtime function counters update handler
-/// Test that you can provide custom handlers for runtime functions counters
-/// updates.
-var globalC: C? = nil
-@inline(never)
-func testFunctionRuntimeCountersUpdateHandler() {
- print("TEST: Provide runtime function counters update handler")
- let l: List<Int>? = List(1, List(2, List(3, List(4, List(5)))))
- let oldHandler =
- _RuntimeFunctionCounters.setGlobalRuntimeFunctionCountersUpdateHandler(
- handler: updatesHandler)
- globalC = C()
- globalC = nil
- let len = length(l!)
- _ = _RuntimeFunctionCounters.setGlobalRuntimeFunctionCountersUpdateHandler(
- handler: oldHandler)
- print("Restored old handler")
- print(len)
-}
-
-/// Enable runtime function counters stats collection.
-_RuntimeFunctionCounters.enableRuntimeFunctionCountersUpdates()
-
-/// Test collection of references inside different types of objects.
-testCollectReferencesInsideObject()
-
-/// Test some APIs from _RuntimeFunctionCounters.
-testRuntimeCounters()
-
-/// Test dumping of counters for all objects.
-_RuntimeFunctionCounters.dumpObjectsRuntimeFunctionPointers()
-
-/// Test runtime function counters for a List object.
-testLists()
-
-/// Test the _measureRuntimeFunctionCountersDiffs API.
-testMeasureRuntimeFunctionCountersDiffs()
-
-/// Test that you can provide custom handlers for runtime functions counters updates.
-testFunctionRuntimeCountersUpdateHandler()
diff --git a/tools/swift-demangle/swift-demangle.cpp b/tools/swift-demangle/swift-demangle.cpp
index e324425..8fdbd85 100644
--- a/tools/swift-demangle/swift-demangle.cpp
+++ b/tools/swift-demangle/swift-demangle.cpp
@@ -49,6 +49,10 @@
llvm::cl::desc("Remangle test mode (show the remangled string)"));
static llvm::cl::opt<bool>
+RemangleRtMode("remangle-objc-rt",
+ llvm::cl::desc("Remangle to the ObjC runtime name mangling scheme"));
+
+static llvm::cl::opt<bool>
RemangleNew("remangle-new",
llvm::cl::desc("Remangle the symbol with new mangling scheme"));
@@ -121,6 +125,12 @@
if (hadLeadingUnderscore) llvm::outs() << '_';
llvm::outs() << remangled;
return;
+ } else if (RemangleRtMode) {
+ std::string remangled = name;
+ if (pointer) {
+ remangled = swift::Demangle::mangleNodeOld(pointer);
+ }
+ llvm::outs() << remangled;
}
if (!TreeOnly) {
if (RemangleNew) {
diff --git a/utils/build-script-impl b/utils/build-script-impl
index 44723df..bcb9e55 100755
--- a/utils/build-script-impl
+++ b/utils/build-script-impl
@@ -2118,6 +2118,11 @@
)
fi
+ if [ "${SWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS}" == "" ] ; then
+ SWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS="${SWIFT_STDLIB_ENABLE_ASSERTIONS}"
+ fi
+
+
cmake_options=(
"${cmake_options[@]}"
-DCMAKE_C_FLAGS="$(swift_c_flags ${host})"
@@ -2131,6 +2136,7 @@
-DSWIFT_STDLIB_ASSERTIONS:BOOL=$(true_false "${SWIFT_STDLIB_ENABLE_ASSERTIONS}")
-DSWIFT_STDLIB_ENABLE_RESILIENCE:BOOL=$(true_false "${SWIFT_STDLIB_ENABLE_RESILIENCE}")
-DSWIFT_STDLIB_USE_NONATOMIC_RC:BOOL=$(true_false "${SWIFT_STDLIB_USE_NONATOMIC_RC}")
+ -DSWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS:BOOL=$(true_false "${SWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS}")
-DSWIFT_NATIVE_LLVM_TOOLS_PATH:STRING="${native_llvm_tools_path}"
-DSWIFT_NATIVE_CLANG_TOOLS_PATH:STRING="${native_clang_tools_path}"
-DSWIFT_NATIVE_SWIFT_TOOLS_PATH:STRING="${native_swift_tools_path}"
diff --git a/validation-test/execution_crashers/Inputs/arc_36509461.h b/validation-test/execution/Inputs/arc_36509461.h
similarity index 100%
rename from validation-test/execution_crashers/Inputs/arc_36509461.h
rename to validation-test/execution/Inputs/arc_36509461.h
diff --git a/validation-test/execution_crashers/Inputs/arc_36509461.m b/validation-test/execution/Inputs/arc_36509461.m
similarity index 100%
rename from validation-test/execution_crashers/Inputs/arc_36509461.m
rename to validation-test/execution/Inputs/arc_36509461.m
diff --git a/validation-test/execution_crashers/Inputs/custom-modules/foo.h b/validation-test/execution/Inputs/custom-modules/foo.h
similarity index 100%
rename from validation-test/execution_crashers/Inputs/custom-modules/foo.h
rename to validation-test/execution/Inputs/custom-modules/foo.h
diff --git a/validation-test/execution_crashers/Inputs/custom-modules/module.modulemap b/validation-test/execution/Inputs/custom-modules/module.modulemap
similarity index 100%
rename from validation-test/execution_crashers/Inputs/custom-modules/module.modulemap
rename to validation-test/execution/Inputs/custom-modules/module.modulemap
diff --git a/validation-test/execution_crashers/Inputs/dsohandle-first.swift b/validation-test/execution/Inputs/dsohandle-first.swift
similarity index 100%
rename from validation-test/execution_crashers/Inputs/dsohandle-first.swift
rename to validation-test/execution/Inputs/dsohandle-first.swift
diff --git a/validation-test/execution_crashers/Inputs/dsohandle-second.swift b/validation-test/execution/Inputs/dsohandle-second.swift
similarity index 100%
rename from validation-test/execution_crashers/Inputs/dsohandle-second.swift
rename to validation-test/execution/Inputs/dsohandle-second.swift
diff --git a/validation-test/execution_crashers/arc_36509461.swift b/validation-test/execution/arc_36509461.swift
similarity index 97%
rename from validation-test/execution_crashers/arc_36509461.swift
rename to validation-test/execution/arc_36509461.swift
index b80fca7..56f4603 100644
--- a/validation-test/execution_crashers/arc_36509461.swift
+++ b/validation-test/execution/arc_36509461.swift
@@ -7,7 +7,7 @@
// REQUIRES: executable_test
// REQUIRES: asan_runtime
// REQUIRES: objc_interop
-// UNSUPPORTED: CPU=i386
+// REQUIRES: OS=macosx
import Foundation
diff --git a/validation-test/execution_crashers/crashers_fixed/rdar33767511.swift b/validation-test/execution/crashers_fixed/rdar33767511.swift
similarity index 100%
rename from validation-test/execution_crashers/crashers_fixed/rdar33767511.swift
rename to validation-test/execution/crashers_fixed/rdar33767511.swift
diff --git a/validation-test/execution_crashers/dsohandle-multi-module.swift b/validation-test/execution/dsohandle-multi-module.swift
similarity index 100%
rename from validation-test/execution_crashers/dsohandle-multi-module.swift
rename to validation-test/execution/dsohandle-multi-module.swift
diff --git a/validation-test/execution_crashers/interpret-with-dependencies-linux.swift b/validation-test/execution/interpret-with-dependencies-linux.swift
similarity index 100%
rename from validation-test/execution_crashers/interpret-with-dependencies-linux.swift
rename to validation-test/execution/interpret-with-dependencies-linux.swift
diff --git a/validation-test/execution_crashers/interpret-with-dependencies.swift b/validation-test/execution/interpret-with-dependencies.swift
similarity index 100%
rename from validation-test/execution_crashers/interpret-with-dependencies.swift
rename to validation-test/execution/interpret-with-dependencies.swift
diff --git a/validation-test/execution_crashers/testability.swift b/validation-test/execution/testability.swift
similarity index 100%
rename from validation-test/execution_crashers/testability.swift
rename to validation-test/execution/testability.swift
diff --git a/validation-test/stdlib/MicroStdlib/Inputs/RuntimeStubs.c b/validation-test/stdlib/MicroStdlib/Inputs/RuntimeStubs.c
index 637b10e..eaa1120 100644
--- a/validation-test/stdlib/MicroStdlib/Inputs/RuntimeStubs.c
+++ b/validation-test/stdlib/MicroStdlib/Inputs/RuntimeStubs.c
@@ -1,12 +1,12 @@
int $SBi32_N;
int $SBi64_N;
int $SBi8_N;
-void _swift_getEnumCaseSinglePayload(void) {}
-void _swift_getGenericMetadata(void) {}
-void _swift_slowAlloc(void) {}
-void _swift_slowDealloc(void) {}
-void _swift_storeEnumTagSinglePayload(void) {}
+void swift_getEnumCaseSinglePayload(void) {}
+void swift_getGenericMetadata(void) {}
+void swift_slowAlloc(void) {}
+void swift_slowDealloc(void) {}
+void swift_storeEnumTagSinglePayload(void) {}
void swift_allocateGenericValueMetadata(void) {}
void swift_initEnumMetadataSinglePayload(void) {}
-void _swift_retain(){}
+void swift_retain(){}
void swift_allocBox(){}
