We don't want the user to override these flags because that file
needs to be compiled in a very specific way.
Re-applies #178 (365e53632e)
Related to #183Fixes#177
The current implementation uses Vectored Exception Handlers. This implementation is too greedy, and invokes _objc_unexpected_exception for (certain) exceptions which would be handled by the application itself.
* Implement PowerPC block trampoline
* Adjust pagesize on ppc64
* Skip UnexpectedException test for PowerPC
* Move PAGE_SIZE to asmconstants.h
* Use PAGE_SIZE and PAGE_SHIFT macros for PowerPC
* Add ppc64el and powerpc qemu-crossbuild targets
* Add NO_SAFE_CACHING definition and guards
* Do not export objc_method_cache_version on ppc32
---------
Co-authored-by: David Chisnall <davidchisnall@users.noreply.github.com>
The fast paths follow the pattern that we established for fast ARC:
Framework base classes can opt in by implementing a `+_TrivialAllocInit`
method.
This opt-in behaviour is inherited and is removed implicitly in any
subclass that implements alloc or init methods (alloc and init are
treated independently).
Compilers can emit calls to `objc_alloc(cls)` instead of `[cls alloc]`,
`objc_allocWithZone(cls)` instead of `[cls allocWithZone: NULL]`, and
`objc_alloc_init` instead of `[[cls alloc] init]`.
Direct methods don't require very much support in the runtime. Apple
reuses their fast path for `-self` (which is supported only in the Apple
fork of clang, not the upstream version) for a fast init. Given that
the first few fields of the runtime's class structure have been stable
for around 30 years, I'm happy moving the flags word (and the
initialised bit, in particular) into the public ABI. This lets us do a
fast-path check for whether a class is initialised in class methods and
call `objc_send_initialize` if it isn't. This function is now exposed
as part of the public ABI, it was there already and does the relevant
checks without invoking any of the message-sending machinery.
Fixes#165#169
* Conditionally include ntdll.dll
* Use text relocation instead of GOT
* Use FlushInstructionCache instead of clear_cache for arm64
* Load address in two stages (adrp, add)
* objc_msgSend.aarch64.S add comments
* Add seh directives
* Move .seh_proc into slow sloop section
* Comment out cfi directives
* Substitute raw .seh directives with macros
* Add documentation of SEH annotations
* Detect CPU Architecture with preprocessor
* Cleanup CMakeLists.txt
Co-authored-by: David Chisnall <davidchisnall@users.noreply.github.com>
* Remove line in objc_msgSend.aarch64.S
Co-authored-by: David Chisnall <davidchisnall@users.noreply.github.com>
* Change Test CMakeList to use ARCHITECTURE var
* Use existing clear cache macro
* Change _WIN64 to _WIN32 and reorder labels
* Remove macro and replace _WIN64 with _WIN32
* Remove argument from non-win32 macro
---------
Co-authored-by: David Chisnall <davidchisnall@users.noreply.github.com>
This replaces a few home-grown datastructures with third-party ones that
get a lot more testing:
- The home-grown hopscotch hash table is moved to using robin map. The
original was designed to be lock free, but we've been using it behind
a lock for ages.
- The selector list is now a std::vector.
- The types list now use std::forward_list.
This also removes a couple of code paths that haven't been used since we
started using the new ABI data structures internally and upgrading at
load time.
The new code tries to differentiate in the static type system between
registered and unregistered selectors. The check for whether a selector
is registered is fragile and depends on no selector being mapped or
allocated in memory below the total number of selectors. This check can
now disappear on most code paths.
On a single test machine (not guaranteed to be representative) the test
suite now completes around 20% faster.
This adds a dependency on a version of CMake with support for Objective-C,
removing a number of hacks to make CMake work and introduces a few
modernisations:
- Options use CMake's `option` mechanism.
- A lot of things now use generator expressions, which should improve the
things like the multi-config Ninja generator.
- We no longer depend on hacks to build in CI.
At the same time, a few other things are simplified:
- There is no longer support for building without C++ support and we depend on
a C++ standard library, not just a runtime. This makes it possible to use
more C++ features inside the runtime.
- We no longer support clang-cl on Windows and instead require clang.exe.
- Support for the Boehm GC has been removed.
Fixes building for Android arm64-v8a with NDK r25, which no longer supports this flag. Since we were passing this unconditionally we were previously inadvertently disabling NEON support if the flag wasn't set.
When we stopped using CXXFLAGS in eh_personality.s generation, we lost
the ability to propagate -m32 or -target through, so cross-compile
didn't work. These flags are now passed through correctly, so (so
'-pipe -O2' will appear as two arguments, rather than being combined as
a single value that then causes clang to abort with an unknown argument
error, which was the original motivation for this change).
This is the correct fix for #177
The way that we were doing this didn't handle multiple flags and we
actually don't want the user to override these flags because that file
needs to be compiled in a very specific way.
Fixes#177
- Don't try to detect libc++abi. It doesn't actually work, so don't
try it.
- Correctly try to link the standard library.
This should fix the build on GNU/Linux systems with libc++abi.so
installed (including our Ubuntu CI!).
We now, the first time we encounter a foreign exception, throw a C++
exception through a frame that has a custom personality function and
probe the layout of the __cxa_exception structure.
We then use the offsets learned from this along with the public ABI
functions for allocating the structure.
At the same time, add a test that we are correctly setting the count of
uncaught exceptions.
Fixes#146
On Itanium C++ ABI platforms, there are a lot of different variations
that have subtly different structure layouts. This commit adds a
run-time test that throws a C++ exception through a function that has
its personality function replaced with a wrapper so that we can inspect
a C++ exception in controlled conditions.
Initially, this just detects the exception type value used for C++
exceptions.
We need to #include <exception> for this to work, but this brings in the
public definition of `std::type_info` and, unfortunately, that breaks
the private definition that we need in this compilation unit.
Frederik Carlier
Hugo Melder
Sergii Stoian
David Chisnall
Frederik Carlier
Frederik Seiffert
Bernard Cafarelli
Niels Grewe
David Chisnall
David Chisnall
Niels Grewe
Jordan Schidlowsky
Marvin Scholz