mirror of
git://sourceware.org/git/newlib-cygwin.git
synced 2025-02-01 03:50:28 +08:00
8e53c58759
In my build the below are treated as error now and causing failures. I
have described the fixes of each warning below.
In newlib/libc/sys/or1k/mlock.c:
CC libc/sys/or1k/libc_a-mlock.o
newlib/libc/sys/or1k/mlock.c: In function ‘__malloc_lock’:
newlib/libc/sys/or1k/mlock.c:56:19: warning: implicit declaration of function ‘or1k_critical_begin’ [-Wimplicit-function-declaration]
56 | restore = or1k_critical_begin();
| ^~~~~~~~~~~~~~~~~~~
newlib/libc/sys/or1k/mlock.c: In function ‘__malloc_unlock’:
newlib/libc/sys/or1k/mlock.c:93:17: warning: implicit declaration of function ‘or1k_critical_end’ [-Wimplicit-function-declaration]
93 | or1k_critical_end(restore);
| ^~~~~~~~~~~~~~~~~
This patch adds prototypes for functions or1k_critical_begin and
or1k_critical_end to suppress the warning, inline with what we do for
or1k_sync_cas.
In libgloss/or1k/or1k_uart.c:
libgloss/or1k/or1k_uart.c: In function ‘or1k_uart_set_read_cb’:
libgloss/or1k/or1k_uart.c:163:25: warning: passing argument 2 of ‘or1k_interrupt_handler_add’ from incompatible pointer type [-Wincompatible-pointer-types]
163 | _or1k_uart_interrupt_handler, 0);
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
| |
| void (*)(uint32_t) {aka void (*)(long unsigned int)}
In file included from libgloss/or1k/or1k_uart.c:19:
libgloss/or1k/include/or1k-support.h:97:45: note: expected ‘or1k_interrupt_handler_fptr’ {aka ‘void (*)(void *)’} but argument is of type ‘void (*)(uint32_t)’ {aka ‘void (*)(long unsigned int)’}
97 | or1k_interrupt_handler_fptr handler,
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~
The public API is ‘void (*)(void *)' for our interrupt handlers. The
function _or1k_uart_interrupt_hander is the internal default
implementation of the uart IRQ handler and it doesn't use the data
argument.
This patch updates the _or1k_uart_interrupt_handler argument type from
uint32_t to void* allowing the function prototype to match the required
prototype.
If we did have a 64-bit implementation it would be an ABI issue. But,
there never has been one, or1k is only 32-bit.
In libgloss/or1k/interrupts.c:
libgloss/or1k/interrupts.c: In function ‘or1k_interrupt_handler_add’:
libgloss/or1k/interrupts.c:41:52: warning: assignment to ‘void *’ from ‘long unsigned int’ makes pointer from integer without a cast [-Wint-conversion]
41 | _or1k_interrupt_handler_data_ptr_table[id] = (uint32_t) data_ptr;
| ^
The table _or1k_interrupt_handler_data_ptr_table is an array of void*
and data_ptr is void*. There is no need for the cast so remove it.
In libgloss/or1k/sbrk.c:
libgloss/or1k/sbrk.c:23:29: warning: initialization of ‘uint32_t’ {aka ‘long unsigned int’} from ‘uint32_t *’ {aka ‘long unsigned int *’} makes integer from pointer without a cast [-Wint-conversion]
23 | uint32_t _or1k_heap_start = &end;
|
This patch adds a cast, which is safe in or1k as the architecture in
32-bit only. But this code would not be 64-compatible.
Signed-off-by: Stafford Horne <shorne@gmail.com>
This document describes the internals of the port for OpenRISC 1000. The API is documented in or1k-support.h as Doxygen comments. # Data Structures +----------------+ 0x0 | vectors | +----------------+ | text,data,.. | +----------------+ | bss | +----------------+ | heap | | vv | | | | ^^ | | stack(s) | +----------------+ _or1k_board_mem_base + _or1k_board_mem_size ## Stack and Heap The stack is allocated at the end of available physical memory which is defined by each board as _or1k_board_mem_base and _or1k_board_mem_size. The _or1k_stack_top and _or1k_stack_bottom are determined by those variables and _or1k_stack_size (which may be overwritten in _or1k_board_init_early). A second stack for exceptions is allocated as we allow exceptions to be arbitrary complex and call C functions etc. It is not an option to re-use the current software stack as we want to be so generic, that this can also be a virtual memory stack at moment of exception. The exception starts below the normal software stack and is _or1k_exception_stack_size large. Multicore: For each core a stack and exception stack is allocated and the stack pointer set at boot. That is: sp(core0) = _or1k_stack_top, sp(core1) = _or1k_stack_top - _or1k_stack_size, etc. ## _or1k_stack_core (multicore only) An array of pointers to the software stacks (size: 4*or1k_numcores()). It is dynamically allocated from heap in or1k_init by calling sbrk(). The pointers contain the values for stack top pointers as described above. This variable is essentially used on boot of the slave cores to configure the stack register. ## _or1k_exception_stack_core (multicore only) An array of pointers to the exception stacks (size: 4*or1k_numcores()). It is allocated identical as the stack_core array. It is loaded whenever an exception occurs to start with a clean stack in the exception. ## _or1k_exception_handler_table A table of function pointers to the handlers of the exceptions. The generic exception handler checks if an exception handler is registered and calls it. There are 30 exceptions defined (0x0 is not an exception vector and 0x100 is reset which is static). This array resides in BSS and is therefore initialized as 0 (no handler registered) after start. Multicore: As the number of course is not known at compile time, the variable is a pointer to and array of arrays (cores x 30) which is allocated in or1k_init() on heap (using sbrk). ## _or1k_interrupt_handler_table and _or1k_interrupt_handler_table_data_ptr The interrupt handlers are stored identical to to the exception handler table. ## _or1k_reent The struct _or1k_reent contains formerly global data and allows for reentrancy. In the single core case, this is an allocated object, while it is a pointer to an array of structs in the multicore library. It is allocated in _or1k_reent_init() on the heap.