problem using gcc-core for compile qemu

problem using gcc-core for compile qemu

[Juan carlos Rebate]

Good morning happy new year, first of all I am going to ask you that
when you read my case, do not refer me to another tool, do not refer
me to another environment, but above all do not ask me to read because
I already read all of Google and there is no solution , but I refuse
to think that there is not, it is simply that nobody has bothered to
publish it.
I am using the gcc-core 9.3 package to compile qemu, I use this one
because mingw does not incorporate all the features that I am looking
for, and gcc is able to search for resources as it would in linux
whereas mingw cannot unless the paths are edited.
the problem that appears to me is the following:
ERROR: Unrecognized host OS (uname -s reports 'CYGWIN_NT-10.0'), there
are no options to indicate the target, there are no options to avoid
the operating system test, (at least not in a simple way). How could I
solve the failure? I beg that it be done as I have it configured

Re: problem using gcc-core for compile qemu

[Eliot Moss]

Sent from my iPhone

> On Jan 6, 2021, at 10:23 PM, Juan carlos Rebate via Cygwin <cygwin@cygwin.com> wrote:
> 
> Good morning happy new year, first of all I am going to ask you that
> when you read my case, do not refer me to another tool, do not refer
> me to another environment, but above all do not ask me to read because
> I already read all of Google and there is no solution , but I refuse
> to think that there is not, it is simply that nobody has bothered to
> publish it.
> I am using the gcc-core 9.3 package to compile qemu, I use this one
> because mingw does not incorporate all the features that I am looking
> for, and gcc is able to search for resources as it would in linux
> whereas mingw cannot unless the paths are edited.
> the problem that appears to me is the following:
> ERROR: Unrecognized host OS (uname -s reports 'CYGWIN_NT-10.0'), there
> are no options to indicate the target, there are no options to avoid
> the operating system test, (at least not in a simple way). How could I
> solve the failure? I beg that it be done as I have it configured
> --
> Problem reports:      https://cygwin.com/problems.html
> FAQ:                  https://cygwin.com/faq/
> Documentation:        https://cygwin.com/docs.html
> Unsubscribe info:     https://cygwin.com/ml/#unsubscribe-simple

You may want to cross compile from Cygwin to mingw. There are Cygwin FVC packages for that.  Eliot Moss

Re: problem using gcc-core for compile qemu

[Eliot Moss]

On 1/6/2021 10:37 PM, Eliot Moss wrote:
> 
> 
> Sent from my iPhone
> 
>> On Jan 6, 2021, at 10:23 PM, Juan carlos Rebate via Cygwin <cygwin@cygwin.com> wrote:
>>
>> Good morning happy new year, first of all I am going to ask you that
>> when you read my case, do not refer me to another tool, do not refer
>> me to another environment, but above all do not ask me to read because
>> I already read all of Google and there is no solution , but I refuse
>> to think that there is not, it is simply that nobody has bothered to
>> publish it.
>> I am using the gcc-core 9.3 package to compile qemu, I use this one
>> because mingw does not incorporate all the features that I am looking
>> for, and gcc is able to search for resources as it would in linux
>> whereas mingw cannot unless the paths are edited.
>> the problem that appears to me is the following:
>> ERROR: Unrecognized host OS (uname -s reports 'CYGWIN_NT-10.0'), there
>> are no options to indicate the target, there are no options to avoid
>> the operating system test, (at least not in a simple way). How could I
>> solve the failure? I beg that it be done as I have it configured
>> --
>> Problem reports:      https://cygwin.com/problems.html
>> FAQ:                  https://cygwin.com/faq/
>> Documentation:        https://cygwin.com/docs.html
>> Unsubscribe info:     https://cygwin.com/ml/#unsubscribe-simple
> 
> You may want to cross compile from Cygwin to mingw. There are Cygwin FVC packages for that.  Eliot Moss

That's what I get for trying to type on my phone!  FVC ==> GCC

Eliot

Re: problem using gcc-core for compile qemu

[Marco Atzeri]

On 07.01.2021 04:23, Juan carlos Rebate via Cygwin wrote:
> Good morning happy new year, first of all I am going to ask you that
> when you read my case, do not refer me to another tool, do not refer
> me to another environment, but above all do not ask me to read because
> I already read all of Google and there is no solution , but I refuse
> to think that there is not, it is simply that nobody has bothered to
> publish it.

If the upstream developers have not bothered to use a serious
configure system,, I doubt there is a easy solution.

Questions:

Are you trying to build for Cygwin or for Windows in general ?
why you can not use the Windows binaries ?


> I am using the gcc-core 9.3 package to compile qemu, I use this one
> because mingw does not incorporate all the features that I am looking
> for, and gcc is able to search for resources as it would in linux
> whereas mingw cannot unless the paths are edited.
> the problem that appears to me is the following:
> ERROR: Unrecognized host OS (uname -s reports 'CYGWIN_NT-10.0'), there
> are no options to indicate the target, there are no options to avoid
> the operating system test, (at least not in a simple way). How could I
> solve the failure? I beg that it be done as I have it configured

have you looked inside the configure script ?
It clearly needs to be patched for accepting other options,
and that is the reason why autoconf/cmake/.. were developed
some time ago.


Regards
Marco

Re: problem using gcc-core for compile qemu

[Csaba Raduly]

On Thu, 7 Jan 2021 at 15:39, Marco Atzeri via Cygwin <cygwin@cygwin.com> wrote:
...
> have you looked inside the configure script ?
> It clearly needs to be patched for accepting other options,
> and that is the reason why autoconf/cmake/.. were developed
> some time ago.

if check_define __linux__ ; then
  targetos="Linux"
elif check_define _WIN32 ; then
  targetos='MINGW32'
elif check_define __OpenBSD__ ; then
  targetos='OpenBSD'
elif check_define __sun__ ; then
  targetos='SunOS'
elif check_define __HAIKU__ ; then
  targetos='Haiku'
elif check_define __FreeBSD__ ; then
  targetos='FreeBSD'
elif check_define __FreeBSD_kernel__ && check_define __GLIBC__; then
  targetos='GNU/kFreeBSD'
elif check_define __DragonFly__ ; then
  targetos='DragonFly'
elif check_define __NetBSD__; then
  targetos='NetBSD'
elif check_define __APPLE__; then
  targetos='Darwin'
else
  # This is a fatal error, but don't report it yet, because we
  # might be going to just print the --help text, or it might
  # be the result of a missing compiler.
  targetos='bogus'
fi

Looks like the OP is shi^H^Hadly out of luck. The Qemu build system
does not acknowledge the existence of Cygwin.

Csaba
-- 
You can get very substantial performance improvements
by not doing the right thing. - Scott Meyers, An Effective C++11/14 Sampler
So if you're looking for a completely portable, 100% standards-conformant way
to get the wrong information: this is what you want. - Scott Meyers (C++TDaWYK)

Re: problem using gcc-core for compile qemu

[Marco Atzeri]

On 07.01.2021 15:53, Csaba Raduly wrote:
> On Thu, 7 Jan 2021 at 15:39, Marco Atzeri wrote:
> ...
>> have you looked inside the configure script ?
>> It clearly needs to be patched for accepting other options,

as I mentioned.


>> and that is the reason why autoconf/cmake/.. were developed
>> some time ago.
> 
> if check_define __linux__ ; then
>    targetos="Linux"
...

> else
>    # This is a fatal error, but don't report it yet, because we
>    # might be going to just print the --help text, or it might
>    # be the result of a missing compiler.
>    targetos='bogus'
> fi
> 
> Looks like the OP is shi^H^Hadly out of luck. The Qemu build system
> does not acknowledge the existence of Cygwin.
> 
> Csaba
> 

It is not that is impossible, but will likely need a big effort.

As there are Windows binaries, I do not think it is worth

Marco

Re: problem using gcc-core for compile qemu

[Eliot Moss]

On 1/7/2021 11:18 AM, Marco Atzeri via Cygwin wrote:

 > It is not that is impossible, but will likely need a big effort.
 >
 > As there are Windows binaries, I do not think it is worth

Right - I had noticed on the web some mention of people maybe working on
getting qemu going under Cygwin.  There is no reason why that cannot be done
in principle, but since qemu can boot operating systems and such, it requires
proper mapping a many OS calls, etc.

Naturally I have no idea what the OP's overall goal is.  As a computer science
researcher, I have often found that for setups like this, a VirtualBox virtual
machine is better because I can get a well-controlled "pure Linux"
environment, that I can also package up and share with students and
colleagues.  Also, compared with Cygwin, I typically get higher speed.  This
is because there is overhead inherent in modeling Posix on top of Windows via
a library.  A VM runs actual Linux.  Don't get me wrong - I love Cygwin and
use it for much of my work!  I like having Windows apps and tools available
while living is a very Unix-like command-line world.  But it's not the only
thing out there.

Note that a modern alternative to VirtualBox (or vmware) is WSL, the Windows
Subsystem for Linux, which (it turns out) is also a VM.  (Note: Unless things
have changed recently, WSL version 2 (which may offer performance advantages
over WSL version 1) is not compatible with VirtualBox.  They use the hardware
virtualization in "opposite" ways.  WSL 1 can be kept compatible with
VirtualBox, but its emulation of Linux on top of Windows suffers from similar
performance issues to those of Cygwin, especially around the fork() call.)

Anyway, maybe this will contribute to the OP's overall need, maybe not ...

Eliot Moss

Re: problem using gcc-core for compile qemu

[juan carlos rebate rodriguez]

El jue, 07-01-2021 a las 15:39 +0100, Marco Atzeri via Cygwin escribió:
> If the upstream developers have not bothered to use a serious
> configure system,, I doubt there is a easy solution.
> 
> Questions:
> 
> Are you trying to build for Cygwin or for Windows in general ?
> why you can not use the Windows binaries ?


I try to build for standard windows, for this reason I use gcc-core and
not cygwin-gcc, if I can use normal windows binaries, what I cannot is
use mingw because it is not able to find resources in the system while
gcc does can, I can't use virtualbx because what I need is to emulate
the aarch64 architecture, I don't want to use binaries compiled by
others, one of the reasons is that those binaries don't include sd-card 
emulation support, but if those binaries are compiled by me I can
include what I want, if I install this library through the cygwin
package manager and then use gcc-core it is able to search for it, it
is not my desire to get into the swamp and have to modify the
configuration script, the An easier solution would be to try to trick
mingw into looking for external libraries without having to modify
their paths, since when editing them the compilation process slows down
even more than it already is

Re: problem using gcc-core for compile qemu

[Marco Atzeri]

On 07.01.2021 23:33, juan carlos rebate rodriguez via Cygwin wrote:
> El jue, 07-01-2021 a las 15:39 +0100, Marco Atzeri via Cygwin escribió:
>> If the upstream developers have not bothered to use a serious
>> configure system,, I doubt there is a easy solution.
>>
>> Questions:
>>
>> Are you trying to build for Cygwin or for Windows in general ?
>> why you can not use the Windows binaries ?
> 
> 
> I try to build for standard windows, for this reason I use gcc-core and
> not cygwin-gcc, if I can use normal windows binaries, what I cannot is
> use mingw because it is not able to find resources in the system while
> gcc does can, I can't use virtualbx because what I need is to emulate
> the aarch64 architecture, I don't want to use binaries compiled by
> others, one of the reasons is that those binaries don't include sd-card
> emulation support, but if those binaries are compiled by me I can
> include what I want, if I install this library through the cygwin
> package manager and then use gcc-core it is able to search for it, it
> is not my desire to get into the swamp and have to modify the
> configuration script, the An easier solution would be to try to trick
> mingw into looking for external libraries without having to modify
> their paths, since when editing them the compilation process slows down
> even more than it already is

Juan Carlos,
you are misunderstanding what gcc-core is.
gcc-core includes only the compiler that targets Cygwin itself.

To compile for Windows on Cygwin you need to use a cross-compiler.
The 64 bit one is in:

$ cygcheck -l mingw64-i686-gcc-core | grep usr/bin
/usr/bin/i686-w64-mingw32-cpp.exe
/usr/bin/i686-w64-mingw32-gcc.exe
/usr/bin/i686-w64-mingw32-gcc-10.exe
/usr/bin/i686-w64-mingw32-gcc-ar.exe
/usr/bin/i686-w64-mingw32-gcc-nm.exe
/usr/bin/i686-w64-mingw32-gcc-ranlib.exe
/usr/bin/i686-w64-mingw32-gcov.exe
/usr/bin/i686-w64-mingw32-gcov-dump.exe
/usr/bin/i686-w64-mingw32-gcov-tool.exe
/usr/bin/i686-w64-mingw32-lto-dump.exe

however there is another problem for building quemu

---------------------------------------------------
$ PKG_CONFIG_LIBDIR=/usr/x86_64-w64-mingw32/sys-root/mingw ./configure 
--cc=/usr/bin/x86_64-w64-mingw32-gcc.exe 
           Using './build' as the directory for build output

ERROR: glib-2.48 gthread-2.0 is required to compile QEMU
----------------------------------------------------

and the cross gthread package is not present on Cygwin

$ cygcheck -cd |grep mingw64-x86
mingw64-x86_64-binutils                 2.34-1
mingw64-x86_64-bzip2                    1.0.6-4
mingw64-x86_64-gcc-core                 10.2.0-1
mingw64-x86_64-gcc-g++                  10.2.0-1
mingw64-x86_64-gettext                  0.19.8.1-2
mingw64-x86_64-glib2.0                  2.54.3-1
mingw64-x86_64-glib2.0-networking       2.54.1-1
mingw64-x86_64-gmp                      6.1.2-1
mingw64-x86_64-gnutls                   3.5.18-1
mingw64-x86_64-headers                  8.0.0-1
mingw64-x86_64-libffi                   3.2.1-2
mingw64-x86_64-libgcrypt                1.8.2-1
mingw64-x86_64-libgpg-error             1.28-1
mingw64-x86_64-libidn2                  2.0.4-1
mingw64-x86_64-libproxy                 0.4.14-1
mingw64-x86_64-libtasn1                 4.13-1
mingw64-x86_64-libunistring             0.9.6-1
mingw64-x86_64-nettle                   3.4-1
mingw64-x86_64-p11-kit                  0.23.10-1
mingw64-x86_64-pcre                     8.44-1
mingw64-x86_64-runtime                  8.0.0-1
mingw64-x86_64-win-iconv                0.0.6-2
mingw64-x86_64-windows-default-manifest 6.4-1
mingw64-x86_64-winpthreads              8.0.0-1
mingw64-x86_64-xz                       5.2.3-1
mingw64-x86_64-zlib                     1.2.11-1

I suggest you to try using MingW64 enviroment for compiling QEMU

http://mingw-w64.org/

Regards
Marco

Re: problem using gcc-core for compile qemu

[Marco Atzeri]

On 08.01.2021 06:52, Marco Atzeri wrote:
> On 07.01.2021 23:33, juan carlos rebate rodriguez via Cygwin wrote:
>> El jue, 07-01-2021 a las 15:39 +0100, Marco Atzeri via Cygwin escribió:

> To compile for Windows on Cygwin you need to use a cross-compiler.
> The 64 bit one is in:

ehm, copy and paste error.

This is the 32bit one

> $ cygcheck -l mingw64-i686-gcc-core | grep usr/bin
> /usr/bin/i686-w64-mingw32-cpp.exe
> /usr/bin/i686-w64-mingw32-gcc.exe
> /usr/bin/i686-w64-mingw32-gcc-10.exe
> /usr/bin/i686-w64-mingw32-gcc-ar.exe
> /usr/bin/i686-w64-mingw32-gcc-nm.exe
> /usr/bin/i686-w64-mingw32-gcc-ranlib.exe
> /usr/bin/i686-w64-mingw32-gcov.exe
> /usr/bin/i686-w64-mingw32-gcov-dump.exe
> /usr/bin/i686-w64-mingw32-gcov-tool.exe
> /usr/bin/i686-w64-mingw32-lto-dump.exe

and this the 64bit one

$ cygcheck -l mingw64-x86_64-gcc-core |grep usr/bin
/usr/bin/x86_64-w64-mingw32-cpp.exe
/usr/bin/x86_64-w64-mingw32-gcc.exe
/usr/bin/x86_64-w64-mingw32-gcc-10.exe
/usr/bin/x86_64-w64-mingw32-gcc-ar.exe
/usr/bin/x86_64-w64-mingw32-gcc-nm.exe
/usr/bin/x86_64-w64-mingw32-gcc-ranlib.exe
/usr/bin/x86_64-w64-mingw32-gcov.exe
/usr/bin/x86_64-w64-mingw32-gcov-dump.exe
/usr/bin/x86_64-w64-mingw32-gcov-tool.exe
/usr/bin/x86_64-w64-mingw32-lto-dump.exe

Re: problem using gcc-core for compile qemu

[Arthur Norman]

> I can't use virtualbx because what I need is to emulate
> the aarch64 architecture, I don't want to use binaries compiled by
> others, one of the reasons is that those binaries don't include sd-card 
> emulation support...
This is perhaps an off-topic response as regards compiling things on 
cygwin, but some while back I found a range of sets of instructions for 
setting up aarch64 emulation in qemu. When I had any issues running on 
Windows I just used virtualbox to give myself an x86_64 Linux world and 
installed qemu there. And after a while I could buy a Raspberry pi with a 
64-bit cpu and use that, so these days working with aarch64 (and an SD 
card) works best for me on an rpi4 not via emulation. But to find people 
who have worked on adapting and setting up qemu to support aarch64 with an 
SD card you might find it useful to follow the footsteps of those who were 
working towards rpi 64-bit support?
And I like and use cygwin for most of what I do, but when something I want 
to do is better supported by Linux then setting up an Ubuntu via 
virtualbox uses some disc space but does not add much overhead on my 
main W10 machine and lets me build, test and debug there because 
following a path that is already well trodden is often easiest!
Arthur

Re: problem using gcc-core for compile qemu

[Eliot Moss]

On 1/8/2021 3:42 AM, Arthur Norman via Cygwin wrote:
 >> I can't use virtualbx because what I need is to emulate
 >> the aarch64 architecture, I don't want to use binaries compiled by
 >> others, one of the reasons is that those binaries don't include sd-card emulation support...
 > This is perhaps an off-topic response as regards compiling things on cygwin, but some while back I
 > found a range of sets of instructions for setting up aarch64 emulation in qemu. When I had any
 > issues running on Windows I just used virtualbox to give myself an x86_64 Linux world and installed
 > qemu there. And after a while I could buy a Raspberry pi with a 64-bit cpu and use that, so these
 > days working with aarch64 (and an SD card) works best for me on an rpi4 not via emulation. But to
 > find people who have worked on adapting and setting up qemu to support aarch64 with an SD card you
 > might find it useful to follow the footsteps of those who were working towards rpi 64-bit support?
 > And I like and use cygwin for most of what I do, but when something I want to do is better supported
 > by Linux then setting up an Ubuntu via virtualbox uses some disc space but does not add much
 > overhead on my main W10 machine and lets me build, test and debug there because following a path
 > that is already well trodden is often easiest!
 > Arthur

I want to second some of that.  My research regularly involves development for
ARM targets (more commonly 32 bit, but also 64).  I happen to use VirtualBox
and there cross-compile from x86 to ARM.  This works for building even a whole
OS from scratch.  After that I am using gem5, not qemu, but the principle
would be the same.  I also spent less than $100 to set myself up with a
Raspberry Pi and SD card.  (I still need gem5 because I am emulating some
additional hardware that does not physically exist (yet, anyway).)

If you need to cross-compile to an ARM target, you could download the Cygwin
gcc package source and build the cross compiler to aarch 64, along with the
other cross tools from bin utils (I am thinking of nm, objdump, etc.).  Then
you can build binaries for ARM using Cygwin, if you like.  I am not aware of
already existing Cygwin packages for ARM targets, but somebody may have built
them.

One advantage of VirtualBox is that Ubuntu packages fo cross compiling to ARM
already exist so I just install and run them.

Best wishes - Eliot Moss

Re: problem using gcc-core for compile qemu

[Marco Atzeri]

On 08.01.2021 14:06, Eliot Moss wrote:
> On 1/8/2021 3:42 AM, Arthur Norman via Cygwin wrote:
>  >> I can't use virtualbx because what I need is to emulate
>  >> the aarch64 architecture, I don't want to use binaries compiled by
>  >> others, one of the reasons is that those binaries don't include 

> 
> I want to second some of that.
> 
> One advantage of VirtualBox is that Ubuntu packages fo cross compiling 
> to ARM
> already exist so I just install and run them.
> 


building a cross compiler in Cygwin is extremely time consuming.
Better use the Virtual box

Regards
Marco

Re: problem using gcc-core for compile qemu

[juan carlos rebate rodriguez]

El vie, 08-01-2021 a las 08:42 +0000, Arthur Norman escribió:
> > I can't use virtualbx because what I need is to emulate
> > the aarch64 architecture, I don't want to use binaries compiled by
> > others, one of the reasons is that those binaries don't include sd-
> card 
> > emulation support...
> This is perhaps an off-topic response as regards compiling things on 
> cygwin, but some while back I found a range of sets of instructions
> for 
> setting up aarch64 emulation in qemu. When I had any issues running
> on 
> Windows I just used virtualbox to give myself an x86_64 Linux world
> and 
> installed qemu there. And after a while I could buy a Raspberry pi
> with a 
> 64-bit cpu and use that, so these days working with aarch64 (and an
> SD 
> card) works best for me on an rpi4 not via emulation. But to find
> people 
> who have worked on adapting and setting up qemu to support aarch64
> with an 
> SD card you might find it useful to follow the footsteps of those who
> were 
> working towards rpi 64-bit support?
> And I like and use cygwin for most of what I do, but when something I
> want 
> to do is better supported by Linux then setting up an Ubuntu via 
> virtualbox uses some disc space but does not add much overhead on my 
> main W10 machine and lets me build, test and debug there because 
> following a path that is already well trodden is often easiest!
> Arthur
> 

I think I expressed myself incorrectly or I am not able to be
understood, no matter what package I choose. gcc-core does not compile
using the cygwin dll, the one that compiles for that library is cygwin-
gcc.
now I will try to explain my case better,
1 when I use the gcc-core package if it is able to detect the whole
set, the only thing that happens is that the script does not recognize
cygwin nt as a valid operating system.
2 when I use the mingw64-x86_64-gcc package it is not able to compile
without add-ons.
for example when I compile with gcc-core if it is able to detect the
libcaca-devel library, this is the library that qemu asks me for sd-
card support,
However, when I use the package mingw64-x86_64-gcc it is not able to
find it in the system because it is not in its set, for this it is
mandatory to use the gcc-core package (not cygwin-gcc), I do not want
to use linux, I want to keep him as far away from my team as possible,
just because I work for him doesn't mean I want him

Re: problem using gcc-core for compile qemu

[Lee]

On 1/8/21, juan carlos rebate rodriguez via Cygwin  wrote:
>
> I think I expressed myself incorrectly or I am not able to be
> understood, no matter what package I choose. gcc-core does not compile
> using the cygwin dll, the one that compiles for that library is cygwin-
> gcc.
> now I will try to explain my case better,
> 1 when I use the gcc-core package if it is able to detect the whole
> set, the only thing that happens is that the script does not recognize
> cygwin nt as a valid operating system.
> 2 when I use the mingw64-x86_64-gcc package it is not able to compile
> without add-ons.
> for example when I compile with gcc-core if it is able to detect the
> libcaca-devel library, this is the library that qemu asks me for sd-
> card support,
> However, when I use the package mingw64-x86_64-gcc it is not able to
> find it in the system because it is not in its set,

If you use the mingw cross compiler you'll also need some cross compiler tools.
Take a look at
  https://cygwin.com/cgi-bin2/package-grep.cgi?grep=libcaca&arch=x86_64

You probably need to install
mingw64-x86_64-libcaca-0.99.beta19-1 - mingw64-x86_64-libcaca: Color
ASCII art library for Win64 toolchain

Regards,
Lee

Re: problem using gcc-core for compile qemu

[Brian Inglis]

On 2021-01-08 13:54, juan carlos rebate rodriguez via Cygwin wrote:
> El vie, 08-01-2021 a las 08:42 +0000, Arthur Norman escribió:
>>> I can't use virtualbox because what I need is to emulate the aarch64 
>>> architecture, I don't want to use binaries compiled by others, one of
>>> the reasons is that those binaries don't include sd-card emulation 
>>> support...
>> This is perhaps an off-topic response as regards compiling things on 
>> cygwin, but some while back I found a range of sets of instructions for 
>> setting up aarch64 emulation in qemu. When I had any issues running on 
>> Windows I just used virtualbox to give myself an x86_64 Linux world and 
>> installed qemu there. And after a while I could buy a Raspberry pi with a 
>> 64-bit cpu and use that, so these days working with aarch64 (and an SD 
>> card) works best for me on an rpi4 not via emulation. But to find people 
>> who have worked on adapting and setting up qemu to support aarch64 with an 
>> SD card you might find it useful to follow the footsteps of those who were 
>> working towards rpi 64-bit support?
>> And I like and use cygwin for most of what I do, but when something I want 
>> to do is better supported by Linux then setting up an Ubuntu via virtualbox
>> uses some disc space but does not add much overhead on my main W10 machine
>> and lets me build, test and debug there because following a path that is
>> already well trodden is often easiest!

> I think I expressed myself incorrectly or I am not able to be
> understood, no matter what package I choose. gcc-core does not compile
> using the cygwin dll, the one that compiles for that library is cygwin-
> gcc.

Packages gcc-core/g++ are the Cygwin native compilers for the architecture you 
are running the compiler on and uses the Cygwin native DLL.
Packages cygwin32/64-gcc-core/g++ are the Cygwin cross-compilers for the 
architecture you are not running the compiler on and uses the Cygwin DLL for the 
other architecture.
Packages mingw64-i686/x86_64-gcc-core/g++ are the Cygwin cross-compilers for 
each of the Windows architecture runtimes and use only 
mingw64-i686/x86_64-lib... libraries and Windows native DLLs including msvcrt.dll.

> now I will try to explain my case better,
> 1 when I use the gcc-core package if it is able to detect the whole
> set, the only thing that happens is that the script does not recognize
> cygwin nt as a valid operating system.
> 2 when I use the mingw64-x86_64-gcc package it is not able to compile
> without add-ons.

Most complex packages have dependencies on (many) libraries: Cygwin supports 402 
mingw64 development library packages for each architecture, which are used to 
build its own Windows native utilities such as setup-x86/_64, cygcheck, 
cygwin-console-helper, ldh, strace, and the cygwin1.dll itself, which do not 
depend on any Cygwin DLLs e.g.

$ cygcheck `cygpath -m /setup`
C:\...\setup-x86_64.exe
   C:\Windows\system32\ADVAPI32.dll
     C:\Windows\system32\msvcrt.dll
       C:\Windows\system32\ntdll.dll
       C:\Windows\system32\KERNELBASE.dll
     C:\Windows\system32\SECHOST.dll
       C:\Windows\system32\RPCRT4.dll
     C:\Windows\system32\KERNEL32.dll
   C:\Windows\system32\COMCTL32.dll
     C:\Windows\system32\GDI32.dll
       C:\Windows\system32\win32u.dll
     C:\Windows\system32\USER32.dll
   C:\Windows\system32\ole32.dll
     C:\Windows\system32\combase.dll
       C:\Windows\system32\bcryptPrimitives.dll
   C:\Windows\system32\PSAPI.DLL
   C:\Windows\system32\SHELL32.dll
   C:\Windows\system32\SHLWAPI.dll
   C:\Windows\system32\WININET.dll
   C:\Windows\system32\WS2_32.dll
$ cygcheck cygcheck
Found: C:\...\cygwin64\bin\cygcheck.exe
C:\...\cygwin64\bin\cygcheck.exe
   C:\Windows\system32\ADVAPI32.dll
     C:\Windows\system32\msvcrt.dll
       C:\Windows\system32\ntdll.dll
       C:\Windows\system32\KERNELBASE.dll
     C:\Windows\system32\SECHOST.dll
       C:\Windows\system32\RPCRT4.dll
     C:\Windows\system32\KERNEL32.dll
   C:\Windows\system32\PSAPI.DLL
   C:\Windows\system32\USER32.dll
     C:\Windows\system32\win32u.dll
     C:\Windows\system32\GDI32.dll
   C:\Windows\system32\WININET.dll

> for example when I compile with gcc-core if it is able to detect the
> libcaca-devel library, this is the library that qemu asks me for sd-
> card support,

I don't think that is the required library for that function:

$ cygcheck -p libcaca-devel
Found 3 matches for libcaca-devel
libcaca-devel-0.99beta19-?: Color ASCII art library (C development) (installed 
binaries and support files)
...

SD card support requires a hardware device driver and typically a filesystem 
driver in the OS e.g. for FAT, NTFS, CD/DVD, or as utilities for foreign 
filesystems e.g. /usr/sbin/mke2fs, resize2fs, tune2fs, dumpe2fs, e2freefrag, 
e2image, e2fsck, etc. in packages e2fsprogs and e2fsimage.

Cygwin lib...-devel packages are for Cygwin native development with the Cygwin 
native libraries, toolchain, and utilities.

> However, when I use the package mingw64-x86_64-gcc it is not able to
> find it in the system because it is not in its set, for this it is
> mandatory to use the gcc-core package (not cygwin-gcc), I do not want
> to use linux, I want to keep him as far away from my team as possible,
> just because I work for him doesn't mean I want him

You have to install all the required and dependent library packages for that 
cross-compiler architecture e.g. mingw64-<arch>-libcaca-0.99beta19-1 library 
packages:

$ cygcheck -p mingw64-.*libcaca
Found 4 matches for mingw64-.*libcaca
mingw64-i686-libcaca-0.99.beta19-1-src - mingw64-i686-libcaca-src: Color ASCII 
art library for Win32 toolchain (source)
mingw64-i686-libcaca-0.99.beta19-1 - mingw64-i686-libcaca: Color ASCII art 
library for Win32 toolchain (installed binaries and support files)
mingw64-x86_64-libcaca-0.99.beta19-1-src - mingw64-x86_64-libcaca-src: Color 
ASCII art library for Win64 toolchain (source)
mingw64-x86_64-libcaca-0.99.beta19-1 - mingw64-x86_64-libcaca: Color ASCII art 
library for Win64 toolchain (installed binaries and support files)

to allow your package to build.

If required or dependent library packages are not already available in Cygwin, 
you will have to build them using the cross-compiler toolchain and install them 
for use by your package build.

The Cygwin package build utility cygport can help you more easily build Cygwin 
packages, including mingw64 using cross-compiler toolchains, given a URL for the 
upstream source package, and a list of Cygwin required or dependent library, 
toolchain, and utility packages needed (it checks they are all available before 
building).

-- 
Take care. Thanks, Brian Inglis, Calgary, Alberta, Canada

This email may be disturbing to some readers as it contains
too much technical detail. Reader discretion is advised.
[Data in binary units and prefixes, physical quantities in SI.]

Re: problem using gcc-core for compile qemu

[Brian Inglis]

On 2021-01-06 20:23, Juan carlos Rebate via Cygwin wrote:
> Good morning happy new year, first of all I am going to ask you that
> when you read my case, do not refer me to another tool, do not refer
> me to another environment, but above all do not ask me to read because
> I already read all of Google and there is no solution , but I refuse
> to think that there is not, it is simply that nobody has bothered to
> publish it.
> I am using the gcc-core 9.3 package to compile qemu, I use this one
> because mingw does not incorporate all the features that I am looking
> for, and gcc is able to search for resources as it would in linux
> whereas mingw cannot unless the paths are edited.
> the problem that appears to me is the following:
> ERROR: Unrecognized host OS (uname -s reports 'CYGWIN_NT-10.0'), there
> are no options to indicate the target, there are no options to avoid
> the operating system test, (at least not in a simple way). How could I
> solve the failure? I beg that it be done as I have it configured

If qemu used autotools then it could require only autoreconfig.

You need to patch the configure script to recognize __CYGWIN__ and set Cygwin as 
targetos, then pick mainly Linux features if they are supported POSIX 
interfaces, otherwise have a look at the Mingw alternative, and pick features 
suitable for Cygwin.

It might be easier or you might be better just changing the Mingw build to do 
what you want instead.

In either case you could then submit the patches upstream on github as a PR 
(pull request: fork the project repo on github under your account, then clone 
your fork of the repo to your system, create a topic branch, make your changes 
and commits incrementally, then push the branch back to your fork of the repo on 
github, and submit a PR from that to the original upstream qemu repo).
Even if they don't accept the PR, you can still pull and merge updates from the 
upstream repo to your fork and your clone.

-- 
Take care. Thanks, Brian Inglis, Calgary, Alberta, Canada

This email may be disturbing to some readers as it contains
too much technical detail. Reader discretion is advised.
[Data in binary units and prefixes, physical quantities in SI.]