MCPU | MCPU - A Minimal 8Bit CPU in a 32 Macrocell CPLD

The problem was not related to PowerPC architecture. I needed to pass the fatbin file to the host-side compilation command with -Xclang -fcuda-include-gpubinary -Xclang axpy.fatbin to replicate the whole compilation behavior.

Here is the corrected Makefile:

The compiler can only rearrange integer expressions if it knows that the result will be correct for any input allowed by the language.

Because 7 is co-prime to 2, it is impossible to carry out dividing any input by seven with multiplying and shifting.

If you know that it is possible for the input that you intend to provide, then you have to do it yourself using the multiply and shift operators.

Depending on the size of the input, you will have to choose how much to shift so that the output is correct (or at least good enough for your application) and so that the intermediate doesn't overflow. The compiler has no way of knowing what is accurate enough for your application, or what your maximum input will be. If it allows any input up to the maximum of the type, then every multiplication will overflow.

In general GCC will only carry out division using shifting if the divisor is not co-prime to 2, that is if it is a power of two.

Well, having seen the majority of comments suggesting that it is likely an issue with the GDB server, I decided to give another GDB server a go.

The outcome was very pleasing:

For:

core.S

Looking at the GCC docs, __floatundisf converts an unsigned long to a float. If we compile your code* with -O1 and run objdump, we can see that the __floatundisf indeed comes from dividing your u64 by a float:

My first question is, does the order matter here?

Yes, literally from gcc documentation:

-l library

...

It makes a difference where in the command you write this option; the linker searches and processes libraries and object files in the order they are specified. Thus, ‘foo.o -lz bar.o’ searches library ‘z’ after file foo.o but before bar.o. If bar.o refers to functions in ‘z’, those functions may not be loaded.

how to tell the linker(?) that there is a strong definition of the function in another static library, or something along those lines?

Typically in modern embedded:

The clue is in the compiler options you already posted:

-mfpu=fpv5-sp-d16 "sp" means single precision.

You told it not to generate hardware double instructions, which is correct for most Cortex-M7 processors because they can't execute them. If you have an M7 which can then you need to set the correct fpu argument.

From the comment that it works for gcc but it's not working for arm-gcc, it looks like you are using a cross-compiler and you are picking up the libraries for the host architecture instead of the libraries for the target architecture.

When you are using a crosscospiler, you need to make sure that your toolchain environment is properly set, otherwise you will have lot's of problems with the build. Also you need to assure that the libraries which are available your build environment are build for the target architecture. If not, the linker will find the library specified with -L, but inside the library there will be no symbols for your target architecture, so you will get error that the symbols you are using form that library are missing.

I have the solution. The problem was that my project had the legacy libraries actives... Uncheking that option in the project configuration it is running correctly now.

From the Programming Manual PM0214 of STM32F4:

Vector table
The vector table contains the reset value of the stack pointer, and the start addresses, also called exception vectors, for all exception handlers. Figure 11 on page 39 shows the order of the exception vectors in the vector table. The least-significant bit of each vector must be 1, indicating that the exception handler is Thumb code.

So, the LSb = 1 indicates that the instruction pointed by that vector is a Thumb instruction. Cortex-M cores support only Thumb instruction set. The compiler knows that, and makes LSb = 1 automatically. If you somehow manage to make it 0, it won't work.