* Add an assert-based segfault handler to `etc.linux.memoryerror`
* Commit memoryAssertError review feedback
* Indent the MemoryErrorSupported version block
* Fix a bad ucontext_t in memoryerror.d
* Fix bad imports in memoryerror.d
* Use a module-scope version: in memoryerror.d
* Add a memoryerror.d unittest
* Prefer version-else-version... in memoryerror.d
Improvements specific to the makefiles:
- reduce the amount of individual code each makefiles requires to
function.
- provide variables for specifying DFLAGS, CFLAGS, CXXFLAGS etc.,
- properly rerun the tests when DMD or DRUNTIME are updated.
- don't build the few tests that are skipped
- keep object files even after running the tests
Fixes:
- a bunch of tests were silently skipped, these include:
- stdcpp/src/test_array.d (it didn't have any unittest block)
- stdcpp/ C++17 tests are now run on posix, if the compiler supports
it
- uuid/ is now run, not just compiled
- thread/ and gc/ skipped some tests because of misspelling
TESTS (they were doing TEST+= instead of TESTS+=)
- exceptions/src/assert_fail.d wans't being reference in the
Makefile
- added -check=assert to the default flags to gather meaningful
results from running the tests with BUILD=release
- In exceptions/ tests previously skipped when BUILD=release are now
run
The main change that this commit tries to fix is being able to specify
compiler flags. The current makefiles make doing this pretty much
impossible and this has affected at least the ldc project which needs
to patch the makefiles to include variables like DFLAGS_BASE into the
variables used by the makefiles in order to be able to pass its flags
around.
On top of being an actual needed feature, the usage of DFLAGS to
specify test-specific flags (like -Isrc or -dip1000) is against the
standard used by GNU make. According to the standard such variables
are reserved for users to add any compiler arguments they desire and
projects should:
1. make sure that those variables are respected and passed, on the
command line of the compiler, after all project specific flags.
2. pass any required flags outside of DFLAGS (because that variable
can be overwritten by the user).
This was simply accomplished by just renaming the current variables
to something like extra_cflags (note the lower case spelling) to
clearly mark the separation between flags that were specified by the
user and flags that are freely usable in the makefiles.
The flags that the makefiles now respects are presented as a table in
common.mak:
$(CC) $(CXX) $(DMD) # the compiler
$(CFLAGS) $(CXXFLAGS) $(DFLAGS) # flags for the compiler
$(LDFLAGS) ditto $(LDFLAGS.d) # flags for the compiler when it invokes the linker
$(LDLIBS) ditto $(LDLIBS.d) # library names given to the compiler when invoking the linker
$(TARGET_ARCH) ditto $(TARGET_ARCH.d) # undocumented but used in the implicit rules
For the purposes of writing the makefiles most the flags variables
above have an extra_dflags variant which can be used to pass test
specific features. Their usage, coupled with the default rules for
building executables, allows the makefiles to easily specify flags, in
a standard compliant manner, with minimal duplication. As an example:
```
$(OBJDIR)/my_test$(DOTEXE): private extra_dflags += -version=TEST_ME
```
is all that's needed to pass -version=TEST_ME when building the
my_test executable.
As specified above, there are now pattern rules that can build common
artifacts. They are inspired by the GNU makefile standard rules, with
the addition of rules for building D executables and the changes
required to respect the extra_dflags variables.
In terms of having the tests be rerun when DMD or DRUNTIME change, the
current code did accomplish this, to some degree, by having the
druntime/Makefile inject the dependencies, which mostly worked. The
approach is problematic because:
1. the dependencies are added unconditionally, if a target doesn't use
DMD or DRUNTIME it will still be rebuilt.
2. it relies on make deleting the build artifacts across runs, so that
they're always rebuilt when the tests are rerun.
3. it only works inside the dmd project, where the tests are invoked
as part of druntime/Makefile. This has lead to ldc needing to add a
manual command that cleans the build directories of the tests in
order to be able to rerun them.
4. It doesn't take into account LINK_SHARED being able to be specified
on the command line.
The solution is simple, simply have the rules that use DMD or DRUNTIME
depend on them, so when those two change the build artifacts are
rebuilt and any tests that depend on them are rerun.
Signed-off-by: Andrei Horodniceanu <a.horodniceanu@proton.me>
The 22 integration tests came with a mix of removing only ROOT
(generated/OS/BUILD/MODEL) or GENERATED (generated) subdirs as
part of their `make clean`.
And running `make clean` in the druntime dir only cleaned up the
default BUILD=release variant, while running `make unittest` without
explicit BUILD type includes running the integration tests in both
debug and release variants.
Streamline/fix this to always cleaning up ROOT, and running `make clean`
in both variants when running druntime's `make clean`.
* Remove the interface function fullCollectNoStack from the gcinterface
* Fix tests that depend on the GC not scanning the stack.
* Remove all nostack remnants
* Add changelog entry
* druntime/test/*.mak: Replace -Isrc by -Iimport
* Fix Windows tests build: rt/tlsgc.d is not in import/ dir
---------
Co-authored-by: Denis Feklushkin <feklushkin.denis@gmail.com>
* Don't run the test in release mode on Linux; just like for the other
Posix targets.
* Include `-L--export-dynamic` as required dflag (added implicitly to cc
linker cmdline by DMD, but not by LDC), which is required for symbol
resolution in druntime exception backtraces.
The test checks the stack frame of `_Dmain` is in the backtrace, however if unused locals are optimised out and`test` is inlined into `main`
```d
void test()
{
int innerLocal = 20;
throw new Exception("foo");
}
void main(string[] args)
{
string myLocal = "bar";
test();
}
```
then the point at which the untapped exception is thrown is at the start of D main - not somewhere in the middle of it - and so GDB prints
```
...
#4 D main (args=...)
```
rather than
```
...
#4 0xSOMEADDRESS in D main (args=...)
```
