Looking to make a GDC-12 mingw64 package
Preetpal
preetpal.sohal at gmail.com
Mon Sep 5 07:12:46 UTC 2022
On Saturday, 21 May 2022 at 21:18:15 UTC, Chris Piker wrote:
> Hi GDC
>
> I've been able to build gdc-12.1 on ubuntu20 using
> ```
> wget
> http://mirrors.concertpass.com/gcc/releases/gcc-12.1.0/gcc-12.1.0.tar.xz
> tar -xvf gcc-12.1.0.tar.xz
> cd gcc-12.1.0
> mkdir build
> cd build
> ../configure --prefix=/usr/local/gcc12 --enable-languages=d \
> --enable-libphobos-checking --disable-multilib
> --program-suffix=-12
> make -j6
> make install
> ```
>
> Now I'm looking to repeat the process for mingw64. I see that
> I'll need an older version of gdc first, say 11.3. So that's
> okay, I'll build it twice, but in general I'm wondering if:
>
> 1. Anyone has built gdc-11 in the mingw64 environment since
> it seems a few patches are required?
>
> 2. How we might go about creating a pacman package for gdc-12
> since it requires an existing D compiler?
>
> The first one is just an information request since the old
> PKGBUILD files are on github, but the second one is a bit more
> daunting. Without a previous version of gdc to build gdc it
> might be hard to get a mingw64 package accepted.
>
> Thanks
My response to the the numbered questions:
1. I have successfully built gdc version 11.3.0 using gcc 12.2.0
(this is possible due to the others who have done work on porting
GDC to Windows) in the mingw64 environment by modifying the
[MINGW-packages gcc PKGBUILD build
script](https://github.com/preetpalS/MINGW-packages/blob/fc660082fabe2181cae188cb10a99566d8301768/mingw-w64-gcc/PKGBUILD) that is used for building all the GCC packages (like the gfortran, gcc, objective-c/c++, libgccjit, and Ada packages). I used the command `MAKEFLAGS="-j12" MINGW_ARCH=mingw64 makepkg-mingw -sLf` and this [PKGBUILD build script](https://github.com/preetpalS/MINGW-packages/blob/gcc-11.3.0/mingw-w64-gdc/PKGBUILD) based on the last version (https://github.com/preetpalS/MINGW-packages/commit/fc660082fabe2181cae188cb10a99566d8301768) of the GCC build script that built version 11.3 of the compiler. Note that it is a WIP as I have not added any code to package the built gdc compiler and there are also some other issues (see below).
2. To build a package for gdc-12, you will have to compile gdc
(gcc version 11 (11.3 or later)) with the same configuration as
the rest of the gcc packages and then use that compiled gdc to
bootstrap gdc-12 as a part of the build process of gcc-12.2.0 (or
a later version). For gdc, I think you could create a separate
package that is based on version 11.3 of the gcc sources, then
once that is in the package system, modify the PKGBUILD script
for the main gcc package so that it includes the necessary
packaging for gdc and in a single commit add that change as well
as remove the separate gdc package to get it in the system.
Here is the diff of the PKGBUILD script I used for gdc versus
what was used for GCC version 11.3:
```
$ diff PKGBUILD ../mingw-w64-gcc/PKGBUILD
8,10c8,10
< _enable_ada=no
< _enable_objc=no
< _enable_jit=no
---
> _enable_ada=yes
> _enable_objc=yes
> _enable_jit=yes
185c185
< local _languages="d"
---
> local _languages="c,lto,c++,fortran"
224a225
> --enable-threads=${_threads} \
232d232
< --enable-libphobos \
```
Here are some issues that I encountered:
- The only relevant changes related to gdc in the PKGBUILD script
is the enabling of libphobos (`--enable-libphobos`) in the
configure flags and the removal of the flag that changes the
default threading of GCC on Windows to posix
(`--enable-threads=${_threads}` where `_threads="posix"`). The
main issue related to posix threads has already been reported in
the [GDC issue
tracker](https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104654) and
based on my limited testing I believe that it is the *only issue*
on the gdc side that is preventing gdc from being package for
mingw64 (in msys2).
- When compiling gcc 11.3.0 without any modifications for gdc,
Ada could not be compiled so I disabled it in the PKGBUILD script.
- When compiling gcc 11.3.0 with posix threading not being the
default, libgccjit did not compile (I also disabled objc and
fortran; c, lto, and c++ are also built even when d is the only
language in the `local_languages` variable).
The gdc compiler appears to be working on Windows with no issues
(with gcc's default threading on Windows) based on a couple of
tests:
```
preet at DESKTOP MINGW64
/b/D/gdc/MINGW-packages-gdc-11.3.0-build/mingw-w64-gdc/tests_for_d_compiler
$ cat message_passing.d
import std.stdio : writeln;
import std.concurrency : receive, receiveOnly,
send, spawn, thisTid, Tid;
/*
A custom struct that is used as a message
for a little thread army.
*/
struct NumberMessage {
int number;
this(int i) {
this.number = i;
}
}
/*
Message is used as a stop sign for other
threads
*/
struct CancelMessage {
}
/// Acknowledge a CancelMessage
struct CancelAckMessage {
}
/*
The thread worker main
function which gets its parent id
passed as argument.
*/
void worker(Tid parentId)
{
bool canceled = false;
writeln("Starting ", thisTid, "...");
while (!canceled) {
receive(
(NumberMessage m) {
writeln("Received int: ", m.number);
},
(string text) {
writeln("Received string: ", text);
},
(CancelMessage m) {
writeln("Stopping ", thisTid, "...");
send(parentId, CancelAckMessage());
canceled = true;
}
);
}
}
void main()
{
Tid[] threads;
// Spawn 10 little worker threads.
for (size_t i = 0; i < 10; ++i) {
threads ~= spawn(&worker, thisTid);
}
// Odd threads get a number, even threads
// a string!
foreach(int idx, ref tid; threads) {
import std.string : format;
if (idx % 2)
send(tid, NumberMessage(idx));
else
send(tid, format("T=%d", idx));
}
// And all threads get the cancel message!
foreach(ref tid; threads) {
send(tid, CancelMessage());
}
// And we wait until all threads have
// acknowledged their stop request
foreach(ref tid; threads) {
receiveOnly!CancelAckMessage;
writeln("Received CancelAckMessage!");
}
}
preet at DESKTOP MINGW64
/b/D/gdc/MINGW-packages-gdc-11.3.0-build/mingw-w64-gdc/tests_for_d_compiler
$ ../src/mingw64/bin/gdc.exe message_passing.d -o message_passing
message_passing.d:64:5: warning: foreach: loop index implicitly
converted from 'size_t' to 'int' [-Wdeprecated]
64 | foreach(int idx, ref tid; threads) {
| ^
preet at DESKTOP MINGW64
/b/D/gdc/MINGW-packages-gdc-11.3.0-build/mingw-w64-gdc/tests_for_d_compiler
$ ./message_passing.exe
Starting Tid(1b97d031100)...
Starting Tid(1b97d031200)...
Starting Tid(1b97d031300)...
Starting Tid(1b97d031400)...
Starting Tid(1b97d031500)...
Starting Tid(1b97d031600)...
Starting Tid(1b97d031700)...
Starting Tid(1b97d031800)...
Starting Tid(1b97d031900)...
Starting Tid(1b97d031a00)...
Received string: T=2
Received string: T=0
Received string: T=4
Received int: 5
Received string: T=8
Received int: 7
Received int: 3
Received int: 1
Received string: T=6
Received int: 9
Stopping Tid(1b97d031200)...
Stopping Tid(1b97d031500)...
Stopping Tid(1b97d031600)...
Stopping Tid(1b97d031800)...
Stopping Tid(1b97d031700)...
Stopping Tid(1b97d031900)...
Stopping Tid(1b97d031100)...
Stopping Tid(1b97d031a00)...
Received CancelAckMessage!
Received CancelAckMessage!
Stopping Tid(1b97d031400)...
Received CancelAckMessage!
Received CancelAckMessage!
Received CancelAckMessage!
Received CancelAckMessage!
Received CancelAckMessage!
Received CancelAckMessage!
Stopping Tid(1b97d031300)...
Received CancelAckMessage!
Received CancelAckMessage!
preet at DESKTOP MINGW64
/b/D/gdc/MINGW-packages-gdc-11.3.0-build/mingw-w64-gdc/tests_for_d_compiler
$ cat parallelism.d
import std.parallelism : task,
taskPool, TaskPool;
import std.array : array;
import std.stdio : writeln;
import std.range : iota;
string theTask()
{
import core.thread : dur, Thread;
Thread.sleep( dur!("seconds")(1) );
return "Hello World";
}
void main()
{
// taskpool with two threads
auto myTaskPool = new TaskPool(2);
// Stopping the task pool is important!
scope(exit) myTaskPool.stop();
// Start long running task
// and do some other stuff in the mean
// time..
auto task = task!theTask;
myTaskPool.put(task);
auto arr = iota(1, 10).array;
foreach(ref i; myTaskPool.parallel(arr)) {
i = i*i;
}
writeln(arr);
import std.algorithm.iteration : map;
// Use reduce to calculate the sum
// of all squares in parallel.
auto result = taskPool.reduce!"a+b"(
0.0, iota(100).map!"a*a");
writeln("Sum of squares: ", result);
// Get our result we sent to background
// earlier.
writeln(task.yieldForce);
}
preet at DESKTOP MINGW64
/b/D/gdc/MINGW-packages-gdc-11.3.0-build/mingw-w64-gdc/tests_for_d_compiler
$ ../src/mingw64/bin/gdc.exe parallelism.d -o parallelism
preet at DESKTOP MINGW64
/b/D/gdc/MINGW-packages-gdc-11.3.0-build/mingw-w64-gdc/tests_for_d_compiler
$ ./parallelism.exe
[1, 4, 9, 16, 25, 36, 49, 64, 81]
Sum of squares: 328350
Hello World
preet at DESKTOP MINGW64
/b/D/gdc/MINGW-packages-gdc-11.3.0-build/mingw-w64-gdc/tests_for_d_compiler
$ ../src/mingw64/bin/gdc.exe --version
gdc.exe (Rev2, Built by MSYS2 project) 11.3.0
Copyright (C) 2021 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.
There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE.
preet at DESKTOP MINGW64
/b/D/gdc/MINGW-packages-gdc-11.3.0-build/mingw-w64-gdc/tests_for_d_compiler
$ git log -n 1
commit ce1d6c3ada291332c782516ad81626162d39f2d6 (HEAD ->
gcc-11.3.0, origin/gcc-11.3.0)
Author: Preetpal Sohal <preetpal.sohal at gmail.com>
Date: Sun Sep 4 20:23:11 2022 -0700
WIP only build D (other packages need pthreads like jit)
```
More information about the D.gnu
mailing list