newlib | PS Vita Newlib port. | User Interface library

The problem was writing to FLASH memory - it hasn't been correctly initialized.

The proper way to write to flash on MPC5748g using the SDK 3.0.3 is following:

• save flash controller cache
• initialise flash
• check and protect UT block
• unblock an address space
• erase a block in this space
• check if the space block is blank
• program the block
• verify if the block is programmed correctly
• check sum of the programmed data
• restore flash controller cache

The strange behaviour of printf and pointer was due to compiler optimization. After changing the compiler flags to -O0 (no optimization), the error was consistent.

The same consistent error can be achieved when marking the pointers as 'volatile'.

This appears to be the very same bug as discussed in Bugzilla here Bug 95177 - error: array subscript has type char. Basically gcc is inconsistent in its diagnostics and this behavior only appeared in later versions.

As discussed in that thread, passing char to the ctype.h functions could in theory be a problem in case the char would contain anything unknown. These functions are defined as expecting the input to be something representable as unsigned char, see C17 7.4:

In all cases the argument is an int, the value of which shall be representable as an unsigned char or shall equal the value of the macro EOF

Therefore int i = isspace((unsigned char)str[1]); makes the warning go away.

But the warning is as you can tell inconsistent. Which could possibly be explained by when you are using ctype.h, the compiler could sometimes be picking a macro and sometimes a function.

Just disable it and regard it as a false positive. According to the Bugzilla log above, this should now have been fixed very recently. gcc (trunk) and gcc >10.3 doesn't give this warning any longer.

It can't find this function

The function may not be linked into your binary.

• Does your binary call malloc elsewhere?
• Do you link against libc.so or libc.a?
• Does nm a.out | grep ' malloc' find it?

it is fine with finding fns, like memcpy

If your binary calls memcpy and you link against libc.a, then memcpy implementation will be linked in. Using the same nm command from above will show that the memcpy symbol is present and malloc is not.

If you want to call malloc at runtime, you need to make sure it's linked in. One way to achieve this is to add:

When you build a program for "bare metal" that means that you need to configure your toolchain to produce a binary that works on the specific piece of bare metal that you try to run it on. For instance, the binary must:

• put its code somewhere in the machine's memory map where there is either ROM or RAM
• put its data where there is RAM
• make sure that on startup the stack pointer is correctly initialized to point into RAM
• if it wants to print output, include routines which access a suitable device on that machine. This is likely a serial port, and serial ports are often entirely different devices, located at different addresses, on different machines

If any of these things are wrong or don't match the actual machine you run on, the result is typically exactly what you see -- the program crashes without output.

More specifically, rdimon.specs tells the compiler to build in C library functions which do some of this via the "semihosting" debugger ABI (which has support for "print string" and some other things). Your QEMU command line doesn't enable implementation of semihosting (you can turn it on with the -semihosting option), so that won't work at all. But there are probably other problems you're also hitting.

There are similar situations on other 64-bit platforms such as x86-64 and ARM64.

The normal way to load a static address is as a 32-bit immediate, either absolute or pc-relative. This is more efficient than requiring 64-bit immediates every time an address is used, which tend to need a longer and slower sequence of instructions. But it does mean that all static code and data needs to fit in 2 GB.

You can use much more of the 64-bit address space for dynamically allocated objects, since they don't need their addresses coded into the binary. This limit is only for static code and data. Also, I'm not sure about RISC-V, but I believe on other platforms, the 2 GB limit applies separately to each shared library, so a really huge application could still be written by breaking off pieces into shared libraries.

On x86-64 and ARM64, GCC does support a "large" code model in which all static addresses are loaded as 64-bit, with the corresponding performance penalty. It looks like this is not currently supported for RISC-V.

You have to supply the key attribute(s), with the correct type(s), when calling GetItem.

You've included non-key attributes (status). When you supply non-key attributes, your GetItem request will fail with a ValidationException including this error message:

The ESP-IDF build system is built on top of CMake. This means you can use all the standard features of CMake in your files. However, the the ESP-IDF system predefines many functions, and makes many assumptions about the layout of your project, supposedly to make things "easier". Instead of reading CMake documentation, start by reading and understanding the ESP-IDF build system documentation:

https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-guides/build-system.html

It looks to me like there is a particular layout expected for subcomponents, including the format of the CMakeLists.txt file. Specifically, move Metriful under a new directory called components, or add Metriful to EXTRA_COMPONENT_DIRS near the top of your root CMakeLists.txt

If Metriful is not written as an esp-idf component, this may not work. However, the document also describes how to link to "pure CMake" components, which will look something like this (at the end of your root CMakeLists.txt).

Okey, solution was erease the content from autogenerated file, save file and build again...,

After several builds error appear again, and same procedure was success :D

Thanks all that tried to helped me if knows about root issue will be great!

By repeatedly opening the file my code was eating up more and more memory and eventually overwrote part of the memory range allocated via mmap. I solved this by storing the value of the file pointer in the .bss (inputfileptr) and only opening it once: