Mercurial > ecos-v3_0-branch
changeset 2243:6fd46febe457
Warnings, cosmetic fixes from Anthony Tonizzo
line wrap: on
line diff
--- a/packages/services/objloader/current/ChangeLog +++ b/packages/services/objloader/current/ChangeLog @@ -1,31 +1,48 @@ +2006-06-27 Anthony Tonizzo <atonizzo@gmail.com> + + * src/loader_fs.c : Minor cosmetic and formatting changes on all files. + Also got rid of some signed/unsigned comparison which did not show up using + the PPC toolchain but do when compiled with gcc under the synthetic target. + * src/objelf.c : + * src/objloader.c : + * src/relocate_i386.c : + * src/relocate_ppc.c : + * include/elf.h : + * include/loader_fs.h : + * include/objelf.h : + * include/relocate_i386.h : + * include/relocate_ppc.h : + * test/test_mods.c : + * test/library/hello.c : + 2005-07-08 Andrew Lunn <andrew.lunn@ascom.ch> - * include/objelf.h: Include hal_tables.h otherwise we get strange - linker errors. - * cdl/objloader.cdl: Rearranged the building of the test case. - * include/relocate_i386.h (New): - * src/relocate_i386.c (New): Added a relocator for i386. - * src/objelf.c: Fixed various Elf_Rel vs Elf_Rela issues. - * test/load_mods.c: - * test/library/hello.c: Modified to make use of the eCos test - infrastructure. Uses a romfs to hold the object file to be loaded. - -2005-05-10 Anthony Tonizzo <atonizzo@lycos.com> + * include/objelf.h: Include hal_tables.h otherwise we get strange + linker errors. + * cdl/objloader.cdl: Rearranged the building of the test case. + * include/relocate_i386.h (New): + * src/relocate_i386.c (New): Added a relocator for i386. + * src/objelf.c: Fixed various Elf_Rel vs Elf_Rela issues. + * test/load_mods.c: + * test/library/hello.c: Modified to make use of the eCos test + infrastructure. Uses a romfs to hold the object file to be loaded. + +2005-05-10 Anthony Tonizzo <atonizzo@gmail.com> - * include/elf.h: - * include/loader_fs.h: - * include/objelf.h: - * include/relocate_ppc.h: - * src/loader_fs.c: - * src/objelf.c: - * src/objloader.c: - * src/relocate_ppc.c: - * doc/notes.txt: - * cdl/objloader.cdl: - * tests/test_mods.c: - * tests/library/hello.c: - Created OBJLDR package. - + * include/elf.h: + * include/loader_fs.h: + * include/objelf.h: + * include/relocate_ppc.h: + * src/loader_fs.c: + * src/objelf.c: + * src/objloader.c: + * src/relocate_ppc.c: + * doc/notes.txt: + * cdl/objloader.cdl: + * tests/test_mods.c: + * tests/library/hello.c: + Created OBJLDR package. + //=========================================================================== //####ECOSGPLCOPYRIGHTBEGIN#### // -------------------------------------------
--- a/packages/services/objloader/current/cdl/objloader.cdl +++ b/packages/services/objloader/current/cdl/objloader.cdl @@ -39,7 +39,7 @@ # ==================================================================== ######DESCRIPTIONBEGIN#### # -# Author(s): atonizzo (atonizzo@lycos.com) +# Author(s): Anthony Tonizzo (atonizzo@gmail.com) # Contributors: Andrew Lunn # Date: 2005-05-13 #
--- a/packages/services/objloader/current/include/elf.h +++ b/packages/services/objloader/current/include/elf.h @@ -3,7 +3,7 @@ /* ================================================================= * - * elf.f + * elf.h * * ================================================================= * ####ECOSGPLCOPYRIGHTBEGIN#### @@ -43,7 +43,7 @@ * ================================================================= * #####DESCRIPTIONBEGIN#### * - * Author(s): atonizzo@lycos.com + * Author(s): Anthony Tonizzo (atonizzo@gmail.com) * Date: 2005-05-13 * Purpose: * Description:
--- a/packages/services/objloader/current/include/loader_fs.h +++ b/packages/services/objloader/current/include/loader_fs.h @@ -3,7 +3,7 @@ /* ================================================================= * - * loader_fs.c + * loader_fs.h * * ================================================================= * ####ECOSGPLCOPYRIGHTBEGIN#### @@ -43,7 +43,7 @@ * ================================================================= * #####DESCRIPTIONBEGIN#### * - * Author(s): atonizzo@lycos.com + * Author(s): Anthony Tonizzo (atonizzo@gmail.com) * Date: 2005-05-13 * Purpose: * Description: @@ -53,8 +53,10 @@ * ================================================================= */ -size_t cyg_ldr_fs_read( PELF_OBJECT, size_t, size_t, void* ); -cyg_int32 cyg_ldr_fs_seek( PELF_OBJECT, cyg_uint32 ); -cyg_int32 cyg_ldr_fs_close( PELF_OBJECT ); +size_t cyg_ldr_fs_read(PELF_OBJECT, size_t, size_t, void*); +cyg_int32 cyg_ldr_fs_seek(PELF_OBJECT, cyg_uint32); +cyg_int32 cyg_ldr_fs_close(PELF_OBJECT); +PELF_OBJECT cyg_ldr_open_library_fs(char *); +void cyg_ldr_close_library_fs(PELF_OBJECT); #endif // __LOADER_FS_H__
--- a/packages/services/objloader/current/include/objelf.h +++ b/packages/services/objloader/current/include/objelf.h @@ -43,7 +43,7 @@ * ================================================================= * #####DESCRIPTIONBEGIN#### * - * Author(s): atonizzo@lycos.com + * Author(s): Anthony Tonizzo (atonizzo@gmail.com) * Contributors: nickg@ecoscentric.com * Date: 2005-05-13 * Purpose: @@ -62,7 +62,7 @@ //============================================================================== -extern cyg_uint8 *cyg_ldr_last_error; +extern char *cyg_ldr_last_error; //============================================================================== @@ -79,9 +79,9 @@ typedef struct ELF_OBJECT CYG_ADDRWORD ptr; cyg_uint32 mode; - size_t (*read)( struct ELF_OBJECT*, size_t, size_t, void* ); - cyg_int32 (*seek)( struct ELF_OBJECT*, cyg_uint32 ); - cyg_int32 (*close)( struct ELF_OBJECT* ); + size_t (*read)(struct ELF_OBJECT*, size_t, size_t, void*); + cyg_int32 (*seek)(struct ELF_OBJECT*, cyg_uint32); + cyg_int32 (*close)(struct ELF_OBJECT*); // This is the absolute address in memory where the library resides. Elf32_Ehdr* p_elfhdr; @@ -107,38 +107,35 @@ typedef struct ELF_OBJECT #endif #if CYGPKG_SERVICES_OBJLOADER_DEBUG_LEVEL > 0 -void cyg_ldr_print_section_data( PELF_OBJECT ); -void cyg_ldr_print_symbol_names( PELF_OBJECT ); -void cyg_ldr_print_rel_names( PELF_OBJECT ); +void cyg_ldr_print_section_data(PELF_OBJECT); +void cyg_ldr_print_symbol_names(PELF_OBJECT); +void cyg_ldr_print_rel_names(PELF_OBJECT); #endif //============================================================================== // Internal functions -cyg_int32 *cyg_ldr_load_elf_section( PELF_OBJECT, cyg_uint32 ); -void cyg_ldr_delete_elf_section( PELF_OBJECT, cyg_uint32 ); -cyg_int32 *cyg_ldr_section_address( PELF_OBJECT, cyg_uint32 ); -void* cyg_ldr_scan_file( PELF_OBJECT ); -cyg_int32 cyg_ldr_relocate_section( PELF_OBJECT, cyg_uint32 ); -void* cyg_ldr_find_symbol( void*, cyg_uint8* ); -void* cyg_ldr_symbol_address( PELF_OBJECT, cyg_uint32 ); -void* cyg_ldr_external_address( PELF_OBJECT, cyg_uint32 ); +cyg_uint32 *cyg_ldr_load_elf_section(PELF_OBJECT, cyg_uint32); +void cyg_ldr_delete_elf_section(PELF_OBJECT, cyg_uint32); +cyg_uint32 *cyg_ldr_section_address(PELF_OBJECT, cyg_uint32); +void* cyg_ldr_scan_file(PELF_OBJECT); +cyg_int32 cyg_ldr_relocate_section(PELF_OBJECT, cyg_uint32); +void* cyg_ldr_find_symbol(void*, char*); +void* cyg_ldr_symbol_address(PELF_OBJECT, cyg_uint32); +void* cyg_ldr_external_address(PELF_OBJECT, cyg_uint32); //============================================================================== // User interface. -PELF_OBJECT cyg_ldr_open_library( CYG_ADDRWORD, cyg_int32 ); -void cyg_ldr_close_library( void* ); -cyg_uint8* cyg_ldr_error( void ); -void* cyg_ldr_get_symbol( void*, char* ); - -PELF_OBJECT cyg_ldr_open_library_fs( cyg_uint8* ); -void cyg_ldr_close_library_fs( PELF_OBJECT ); +PELF_OBJECT cyg_ldr_open_library(CYG_ADDRWORD, cyg_int32); +void cyg_ldr_close_library(void*); +char* cyg_ldr_error(void); +void* cyg_ldr_get_symbol(void*, char*); //============================================================================== -void *cyg_ldr_malloc( size_t ) CYGBLD_ATTRIB_WEAK; -void cyg_ldr_free( void * ) CYGBLD_ATTRIB_WEAK; +void *cyg_ldr_malloc(size_t) CYGBLD_ATTRIB_WEAK; +void cyg_ldr_free(void *) CYGBLD_ATTRIB_WEAK; //============================================================================== @@ -150,390 +147,390 @@ struct cyg_ldr_table_entry typedef struct cyg_ldr_table_entry cyg_ldr_table_entry; -#define CYG_LDR_TABLE_ENTRY( __name, __symbol_name, __handler ) \ - cyg_ldr_table_entry __name CYG_HAL_TABLE_ENTRY( ldr_table ) = \ +#define CYG_LDR_TABLE_ENTRY(__name, __symbol_name, __handler) \ + cyg_ldr_table_entry __name CYG_HAL_TABLE_ENTRY(ldr_table) = \ { __symbol_name, __handler } //============================================================================== -#define CYG_LDR_TABLE_KAPI_ALARM() \ -CYG_LDR_TABLE_ENTRY( cyg_alarm_create_entry, \ - "cyg_alarm_create", cyg_alarm_create ); \ -CYG_LDR_TABLE_ENTRY( cyg_alarm_delete_entry, \ - "cyg_alarm_delete", cyg_alarm_delete ); \ -CYG_LDR_TABLE_ENTRY( cyg_alarm_initialize_entry, \ - "cyg_alarm_initialize", cyg_alarm_initialize ); \ -CYG_LDR_TABLE_ENTRY( cyg_alarm_get_times_entry, \ - "cyg_alarm_get_times", cyg_alarm_get_times ); \ -CYG_LDR_TABLE_ENTRY( cyg_alarm_enable_entry, \ - "cyg_alarm_enable", cyg_alarm_enable ); \ -CYG_LDR_TABLE_ENTRY( cyg_alarm_disable_entry, \ - "cyg_alarm_disable", cyg_alarm_disable ); +#define CYG_LDR_TABLE_KAPI_ALARM() \ +CYG_LDR_TABLE_ENTRY(cyg_alarm_create_entry, \ + "cyg_alarm_create", cyg_alarm_create); \ +CYG_LDR_TABLE_ENTRY(cyg_alarm_delete_entry, \ + "cyg_alarm_delete", cyg_alarm_delete); \ +CYG_LDR_TABLE_ENTRY(cyg_alarm_initialize_entry, \ + "cyg_alarm_initialize", cyg_alarm_initialize); \ +CYG_LDR_TABLE_ENTRY(cyg_alarm_get_times_entry, \ + "cyg_alarm_get_times", cyg_alarm_get_times); \ +CYG_LDR_TABLE_ENTRY(cyg_alarm_enable_entry, \ + "cyg_alarm_enable", cyg_alarm_enable); \ +CYG_LDR_TABLE_ENTRY(cyg_alarm_disable_entry, \ + "cyg_alarm_disable", cyg_alarm_disable); -#define CYG_LDR_TABLE_KAPI_CLOCK() \ -CYG_LDR_TABLE_ENTRY( cyg_clock_create_entry, \ - "cyg_clock_create", cyg_clock_create ); \ -CYG_LDR_TABLE_ENTRY( cyg_clock_delete_entry, \ - "cyg_clock_delete", cyg_clock_delete ); \ -CYG_LDR_TABLE_ENTRY( cyg_clock_to_counter_entry, \ - "cyg_clock_to_counter", cyg_clock_to_counter ); \ -CYG_LDR_TABLE_ENTRY( cyg_clock_set_resolution_entry, \ - "cyg_clock_set_resolution", cyg_clock_set_resolution ); \ -CYG_LDR_TABLE_ENTRY( cyg_clock_get_resolution_entry, \ - "cyg_clock_get_resolution",cyg_clock_get_resolution ); \ -CYG_LDR_TABLE_ENTRY( cyg_real_time_clock_entry, \ - "cyg_real_time_clock", cyg_real_time_clock ); \ -CYG_LDR_TABLE_ENTRY( cyg_current_time_entry, \ - "cyg_current_time", cyg_current_time ); +#define CYG_LDR_TABLE_KAPI_CLOCK() \ +CYG_LDR_TABLE_ENTRY(cyg_clock_create_entry, \ + "cyg_clock_create", cyg_clock_create); \ +CYG_LDR_TABLE_ENTRY(cyg_clock_delete_entry, \ + "cyg_clock_delete", cyg_clock_delete); \ +CYG_LDR_TABLE_ENTRY(cyg_clock_to_counter_entry, \ + "cyg_clock_to_counter", cyg_clock_to_counter); \ +CYG_LDR_TABLE_ENTRY(cyg_clock_set_resolution_entry, \ + "cyg_clock_set_resolution", cyg_clock_set_resolution); \ +CYG_LDR_TABLE_ENTRY(cyg_clock_get_resolution_entry, \ + "cyg_clock_get_resolution",cyg_clock_get_resolution); \ +CYG_LDR_TABLE_ENTRY(cyg_real_time_clock_entry, \ + "cyg_real_time_clock", cyg_real_time_clock); \ +CYG_LDR_TABLE_ENTRY(cyg_current_time_entry, \ + "cyg_current_time", cyg_current_time); -#define CYG_LDR_TABLE_KAPI_COND() \ -CYG_LDR_TABLE_ENTRY( cyg_cond_init_entry, \ - "cyg_cond_init", cyg_cond_init ); \ -CYG_LDR_TABLE_ENTRY( cyg_cond_destroy_entry, \ - "cyg_cond_destroy", cyg_cond_destroy ); \ -CYG_LDR_TABLE_ENTRY( cyg_cond_wait_entry, \ - "cyg_cond_wait", cyg_cond_wait ); \ -CYG_LDR_TABLE_ENTRY( cyg_cond_signal_entry, \ - "cyg_cond_signal", cyg_cond_signal ); \ -CYG_LDR_TABLE_ENTRY( cyg_cond_broadcast_entry, \ - "cyg_cond_broadcast", cyg_cond_broadcast ); \ -CYG_LDR_TABLE_ENTRY( cyg_cond_timed_wait_entry, \ - "cyg_cond_timed_wait", cyg_cond_timed_wait ); +#define CYG_LDR_TABLE_KAPI_COND() \ +CYG_LDR_TABLE_ENTRY(cyg_cond_init_entry, \ + "cyg_cond_init", cyg_cond_init); \ +CYG_LDR_TABLE_ENTRY(cyg_cond_destroy_entry, \ + "cyg_cond_destroy", cyg_cond_destroy); \ +CYG_LDR_TABLE_ENTRY(cyg_cond_wait_entry, \ + "cyg_cond_wait", cyg_cond_wait); \ +CYG_LDR_TABLE_ENTRY(cyg_cond_signal_entry, \ + "cyg_cond_signal", cyg_cond_signal); \ +CYG_LDR_TABLE_ENTRY(cyg_cond_broadcast_entry, \ + "cyg_cond_broadcast", cyg_cond_broadcast); \ +CYG_LDR_TABLE_ENTRY(cyg_cond_timed_wait_entry, \ + "cyg_cond_timed_wait", cyg_cond_timed_wait); -#define CYG_LDR_TABLE_KAPI_COUNTER() \ -CYG_LDR_TABLE_ENTRY( cyg_counter_create_entry, \ - "cyg_counter_create", cyg_counter_create ); \ -CYG_LDR_TABLE_ENTRY( cyg_counter_delete_entry, \ - "cyg_counter_delete", cyg_counter_delete ); \ -CYG_LDR_TABLE_ENTRY( cyg_counter_current_value_entry, \ - "cyg_counter_current_value", cyg_counter_current_value ); \ -CYG_LDR_TABLE_ENTRY( cyg_counter_set_value_entry, \ - "cyg_counter_set_value", cyg_counter_set_value ); \ -CYG_LDR_TABLE_ENTRY( cyg_counter_tick_entry, \ - "cyg_counter_tick", cyg_counter_tick ); \ -CYG_LDR_TABLE_ENTRY( cyg_counter_multi_tick_entry, \ - "cyg_counter_multi_tick", cyg_counter_multi_tick ); +#define CYG_LDR_TABLE_KAPI_COUNTER() \ +CYG_LDR_TABLE_ENTRY(cyg_counter_create_entry, \ + "cyg_counter_create", cyg_counter_create); \ +CYG_LDR_TABLE_ENTRY(cyg_counter_delete_entry, \ + "cyg_counter_delete", cyg_counter_delete); \ +CYG_LDR_TABLE_ENTRY(cyg_counter_current_value_entry, \ + "cyg_counter_current_value", cyg_counter_current_value); \ +CYG_LDR_TABLE_ENTRY(cyg_counter_set_value_entry, \ + "cyg_counter_set_value", cyg_counter_set_value); \ +CYG_LDR_TABLE_ENTRY(cyg_counter_tick_entry, \ + "cyg_counter_tick", cyg_counter_tick); \ +CYG_LDR_TABLE_ENTRY(cyg_counter_multi_tick_entry, \ + "cyg_counter_multi_tick", cyg_counter_multi_tick); -#define CYG_LDR_TABLE_KAPI_EXCEPTIONS() \ -CYG_LDR_TABLE_ENTRY( cyg_exception_set_handler_entry, \ - "cyg_exception_set_handler", cyg_exception_set_handler ); \ -CYG_LDR_TABLE_ENTRY( cyg_exception_clear_handler_entry, \ - "cyg_exception_clear_handler", \ - cyg_exception_clear_handler ); \ -CYG_LDR_TABLE_ENTRY( cyg_exception_call_handler_entry, \ - "cyg_exception_call_handler", \ - cyg_exception_call_handler ); +#define CYG_LDR_TABLE_KAPI_EXCEPTIONS() \ +CYG_LDR_TABLE_ENTRY(cyg_exception_set_handler_entry, \ + "cyg_exception_set_handler", cyg_exception_set_handler); \ +CYG_LDR_TABLE_ENTRY(cyg_exception_clear_handler_entry, \ + "cyg_exception_clear_handler", \ + cyg_exception_clear_handler); \ +CYG_LDR_TABLE_ENTRY(cyg_exception_call_handler_entry, \ + "cyg_exception_call_handler", \ + cyg_exception_call_handler); -#define CYG_LDR_TABLE_KAPI_FLAG() \ -CYG_LDR_TABLE_ENTRY( cyg_flag_init_entry, \ - "cyg_flag_init", cyg_flag_init ); \ -CYG_LDR_TABLE_ENTRY( cyg_flag_destroy_entry, \ - "cyg_flag_destroy", cyg_flag_destroy ); \ -CYG_LDR_TABLE_ENTRY( cyg_flag_setbits_entry, \ - "cyg_flag_setbits", cyg_flag_setbits ); \ -CYG_LDR_TABLE_ENTRY( cyg_flag_maskbits_entry, \ - "cyg_flag_maskbits", cyg_flag_maskbits ); \ -CYG_LDR_TABLE_ENTRY( cyg_flag_wait_entry, \ - "cyg_flag_wait", cyg_flag_wait ); \ -CYG_LDR_TABLE_ENTRY( cyg_flag_timed_wait_entry, \ - "cyg_flag_timed_wait", cyg_flag_timed_wait ); \ -CYG_LDR_TABLE_ENTRY( cyg_flag_poll_entry, \ - "cyg_flag_poll", cyg_flag_poll ); \ -CYG_LDR_TABLE_ENTRY( cyg_flag_peek_entry, \ - "cyg_flag_peek", cyg_flag_peek ); \ -CYG_LDR_TABLE_ENTRY( cyg_flag_waiting_entry, \ - "cyg_flag_waiting", cyg_flag_waiting ); +#define CYG_LDR_TABLE_KAPI_FLAG() \ +CYG_LDR_TABLE_ENTRY(cyg_flag_init_entry, \ + "cyg_flag_init", cyg_flag_init); \ +CYG_LDR_TABLE_ENTRY(cyg_flag_destroy_entry, \ + "cyg_flag_destroy", cyg_flag_destroy); \ +CYG_LDR_TABLE_ENTRY(cyg_flag_setbits_entry, \ + "cyg_flag_setbits", cyg_flag_setbits); \ +CYG_LDR_TABLE_ENTRY(cyg_flag_maskbits_entry, \ + "cyg_flag_maskbits", cyg_flag_maskbits); \ +CYG_LDR_TABLE_ENTRY(cyg_flag_wait_entry, \ + "cyg_flag_wait", cyg_flag_wait); \ +CYG_LDR_TABLE_ENTRY(cyg_flag_timed_wait_entry, \ + "cyg_flag_timed_wait", cyg_flag_timed_wait); \ +CYG_LDR_TABLE_ENTRY(cyg_flag_poll_entry, \ + "cyg_flag_poll", cyg_flag_poll); \ +CYG_LDR_TABLE_ENTRY(cyg_flag_peek_entry, \ + "cyg_flag_peek", cyg_flag_peek); \ +CYG_LDR_TABLE_ENTRY(cyg_flag_waiting_entry, \ + "cyg_flag_waiting", cyg_flag_waiting); -#define CYG_LDR_TABLE_KAPI_INTERRUPTS() \ -CYG_LDR_TABLE_ENTRY( cyg_interrupt_create_entry, \ - "cyg_interrupt_create", cyg_interrupt_create ); \ -CYG_LDR_TABLE_ENTRY( cyg_interrupt_delete_entry, \ - "cyg_interrupt_delete", cyg_interrupt_delete ); \ -CYG_LDR_TABLE_ENTRY( cyg_interrupt_attach_entry, \ - "cyg_interrupt_attach", cyg_interrupt_attach ); \ -CYG_LDR_TABLE_ENTRY( cyg_interrupt_detach_entry, \ - "cyg_interrupt_detach", cyg_interrupt_detach ); \ -CYG_LDR_TABLE_ENTRY( cyg_interrupt_get_vsr_entry, \ - "cyg_interrupt_get_vsr", cyg_interrupt_get_vsr ); \ -CYG_LDR_TABLE_ENTRY( cyg_interrupt_set_vsr_entry, \ - "cyg_interrupt_set_vsr", cyg_interrupt_set_vsr ); \ -CYG_LDR_TABLE_ENTRY( cyg_interrupt_disable_entry, \ - "cyg_interrupt_disable", cyg_interrupt_disable ); \ -CYG_LDR_TABLE_ENTRY( cyg_interrupt_enable_entry, \ - "cyg_interrupt_enable", cyg_interrupt_enable ); \ -CYG_LDR_TABLE_ENTRY( cyg_interrupt_mask_entry, \ - "cyg_interrupt_mask", cyg_interrupt_mask ); \ -CYG_LDR_TABLE_ENTRY( cyg_interrupt_mask_intunsafe_entry, \ - "cyg_interrupt_mask_intunsafe", \ - cyg_interrupt_mask_intunsafe ); \ -CYG_LDR_TABLE_ENTRY( cyg_interrupt_unmask_entry, \ - "cyg_interrupt_unmask", cyg_interrupt_unmask ); \ -CYG_LDR_TABLE_ENTRY( cyg_interrupt_unmask_intunsafe_entry, \ - "cyg_interrupt_unmask_intunsafe", \ - cyg_interrupt_unmask_intunsafe ); \ -CYG_LDR_TABLE_ENTRY( cyg_interrupt_acknowledge_entry, \ - "cyg_interrupt_acknowledge", \ - cyg_interrupt_acknowledge ); \ -CYG_LDR_TABLE_ENTRY( cyg_interrupt_configure_entry, \ - "cyg_interrupt_configure", cyg_interrupt_configure ); \ -CYG_LDR_TABLE_ENTRY( cyg_interrupt_set_cpu_entry, \ - "cyg_interrupt_set_cpu", cyg_interrupt_set_cpu ); \ -CYG_LDR_TABLE_ENTRY( cyg_interrupt_get_cpu_entry, \ - "cyg_interrupt_get_cpu", cyg_interrupt_get_cpu ); +#define CYG_LDR_TABLE_KAPI_INTERRUPTS() \ +CYG_LDR_TABLE_ENTRY(cyg_interrupt_create_entry, \ + "cyg_interrupt_create", cyg_interrupt_create); \ +CYG_LDR_TABLE_ENTRY(cyg_interrupt_delete_entry, \ + "cyg_interrupt_delete", cyg_interrupt_delete); \ +CYG_LDR_TABLE_ENTRY(cyg_interrupt_attach_entry, \ + "cyg_interrupt_attach", cyg_interrupt_attach); \ +CYG_LDR_TABLE_ENTRY(cyg_interrupt_detach_entry, \ + "cyg_interrupt_detach", cyg_interrupt_detach); \ +CYG_LDR_TABLE_ENTRY(cyg_interrupt_get_vsr_entry, \ + "cyg_interrupt_get_vsr", cyg_interrupt_get_vsr); \ +CYG_LDR_TABLE_ENTRY(cyg_interrupt_set_vsr_entry, \ + "cyg_interrupt_set_vsr", cyg_interrupt_set_vsr); \ +CYG_LDR_TABLE_ENTRY(cyg_interrupt_disable_entry, \ + "cyg_interrupt_disable", cyg_interrupt_disable); \ +CYG_LDR_TABLE_ENTRY(cyg_interrupt_enable_entry, \ + "cyg_interrupt_enable", cyg_interrupt_enable); \ +CYG_LDR_TABLE_ENTRY(cyg_interrupt_mask_entry, \ + "cyg_interrupt_mask", cyg_interrupt_mask); \ +CYG_LDR_TABLE_ENTRY(cyg_interrupt_mask_intunsafe_entry, \ + "cyg_interrupt_mask_intunsafe", \ + cyg_interrupt_mask_intunsafe); \ +CYG_LDR_TABLE_ENTRY(cyg_interrupt_unmask_entry, \ + "cyg_interrupt_unmask", cyg_interrupt_unmask); \ +CYG_LDR_TABLE_ENTRY(cyg_interrupt_unmask_intunsafe_entry, \ + "cyg_interrupt_unmask_intunsafe", \ + cyg_interrupt_unmask_intunsafe); \ +CYG_LDR_TABLE_ENTRY(cyg_interrupt_acknowledge_entry, \ + "cyg_interrupt_acknowledge", \ + cyg_interrupt_acknowledge); \ +CYG_LDR_TABLE_ENTRY(cyg_interrupt_configure_entry, \ + "cyg_interrupt_configure", cyg_interrupt_configure); \ +CYG_LDR_TABLE_ENTRY(cyg_interrupt_set_cpu_entry, \ + "cyg_interrupt_set_cpu", cyg_interrupt_set_cpu); \ +CYG_LDR_TABLE_ENTRY(cyg_interrupt_get_cpu_entry, \ + "cyg_interrupt_get_cpu", cyg_interrupt_get_cpu); -#define CYG_LDR_TABLE_KAPI_MBOX() \ -CYG_LDR_TABLE_ENTRY( cyg_mbox_create_entry, \ - "cyg_mbox_create", cyg_mbox_create ); \ -CYG_LDR_TABLE_ENTRY( cyg_mbox_delete_entry, \ - "cyg_mbox_delete", cyg_mbox_delete ); \ -CYG_LDR_TABLE_ENTRY( cyg_mbox_get_entry, \ - "cyg_mbox_get", cyg_mbox_get ); \ -CYG_LDR_TABLE_ENTRY( cyg_mbox_timed_get_entry, \ - "cyg_mbox_timed_get", cyg_mbox_timed_get ); \ -CYG_LDR_TABLE_ENTRY( cyg_mbox_tryget_entry, \ - "cyg_mbox_tryget", cyg_mbox_tryget ); \ -CYG_LDR_TABLE_ENTRY( cyg_mbox_peek_item_entry, \ - "cyg_mbox_peek_item", cyg_mbox_peek_item ); \ -CYG_LDR_TABLE_ENTRY( cyg_mbox_put_entry, \ - "cyg_mbox_put", cyg_mbox_put ); \ -CYG_LDR_TABLE_ENTRY( cyg_mbox_timed_put_entry, \ - "cyg_mbox_timed_put", cyg_mbox_timed_put ); \ -CYG_LDR_TABLE_ENTRY( cyg_mbox_tryput_entry, \ - "cyg_mbox_tryput", cyg_mbox_tryput ); \ -CYG_LDR_TABLE_ENTRY( cyg_mbox_peek_entry, \ - "cyg_mbox_peek", cyg_mbox_peek ); \ -CYG_LDR_TABLE_ENTRY( cyg_mbox_waiting_to_get_entry, \ - "cyg_mbox_waiting_to_get", \ - cyg_mbox_waiting_to_get ); \ -CYG_LDR_TABLE_ENTRY( cyg_mbox_waiting_to_put_entry, \ - "cyg_mbox_waiting_to_put", \ - cyg_mbox_waiting_to_put ); +#define CYG_LDR_TABLE_KAPI_MBOX() \ +CYG_LDR_TABLE_ENTRY(cyg_mbox_create_entry, \ + "cyg_mbox_create", cyg_mbox_create); \ +CYG_LDR_TABLE_ENTRY(cyg_mbox_delete_entry, \ + "cyg_mbox_delete", cyg_mbox_delete); \ +CYG_LDR_TABLE_ENTRY(cyg_mbox_get_entry, \ + "cyg_mbox_get", cyg_mbox_get); \ +CYG_LDR_TABLE_ENTRY(cyg_mbox_timed_get_entry, \ + "cyg_mbox_timed_get", cyg_mbox_timed_get); \ +CYG_LDR_TABLE_ENTRY(cyg_mbox_tryget_entry, \ + "cyg_mbox_tryget", cyg_mbox_tryget); \ +CYG_LDR_TABLE_ENTRY(cyg_mbox_peek_item_entry, \ + "cyg_mbox_peek_item", cyg_mbox_peek_item); \ +CYG_LDR_TABLE_ENTRY(cyg_mbox_put_entry, \ + "cyg_mbox_put", cyg_mbox_put); \ +CYG_LDR_TABLE_ENTRY(cyg_mbox_timed_put_entry, \ + "cyg_mbox_timed_put", cyg_mbox_timed_put); \ +CYG_LDR_TABLE_ENTRY(cyg_mbox_tryput_entry, \ + "cyg_mbox_tryput", cyg_mbox_tryput); \ +CYG_LDR_TABLE_ENTRY(cyg_mbox_peek_entry, \ + "cyg_mbox_peek", cyg_mbox_peek); \ +CYG_LDR_TABLE_ENTRY(cyg_mbox_waiting_to_get_entry, \ + "cyg_mbox_waiting_to_get", \ + cyg_mbox_waiting_to_get); \ +CYG_LDR_TABLE_ENTRY(cyg_mbox_waiting_to_put_entry, \ + "cyg_mbox_waiting_to_put", \ + cyg_mbox_waiting_to_put); -#define CYG_LDR_TABLE_KAPI_MEMPOOL_FIX() \ -CYG_LDR_TABLE_ENTRY( cyg_mempool_fix_create_entry, \ - "cyg_mempool_fix_create", cyg_mempool_fix_create ); \ -CYG_LDR_TABLE_ENTRY( cyg_mempool_fix_delete_entry, \ - "cyg_mempool_fix_delete", cyg_mempool_fix_delete ); \ -CYG_LDR_TABLE_ENTRY( cyg_mempool_fix_alloc_entry, \ - "cyg_mempool_fix_alloc", cyg_mempool_fix_alloc ); \ -CYG_LDR_TABLE_ENTRY( cyg_mempool_fix_timed_alloc_entry, \ - "cyg_mempool_fix_timed_alloc", \ - cyg_mempool_fix_timed_alloc ); \ -CYG_LDR_TABLE_ENTRY( cyg_mempool_fix_try_alloc_entry, \ - "cyg_mempool_fix_try_alloc", \ - cyg_mempool_fix_try_alloc ); \ -CYG_LDR_TABLE_ENTRY( cyg_mempool_fix_free_entry, \ - "cyg_mempool_fix_free", cyg_mempool_fix_free ); \ -CYG_LDR_TABLE_ENTRY( cyg_mempool_fix_waiting_entry, \ - "cyg_mempool_fix_waiting", cyg_mempool_fix_waiting ); \ -CYG_LDR_TABLE_ENTRY( cyg_mempool_fix_get_info_entry, \ - "cyg_mempool_fix_get_info", cyg_mempool_fix_get_info ); +#define CYG_LDR_TABLE_KAPI_MEMPOOL_FIX() \ +CYG_LDR_TABLE_ENTRY(cyg_mempool_fix_create_entry, \ + "cyg_mempool_fix_create", cyg_mempool_fix_create); \ +CYG_LDR_TABLE_ENTRY(cyg_mempool_fix_delete_entry, \ + "cyg_mempool_fix_delete", cyg_mempool_fix_delete); \ +CYG_LDR_TABLE_ENTRY(cyg_mempool_fix_alloc_entry, \ + "cyg_mempool_fix_alloc", cyg_mempool_fix_alloc); \ +CYG_LDR_TABLE_ENTRY(cyg_mempool_fix_timed_alloc_entry, \ + "cyg_mempool_fix_timed_alloc", \ + cyg_mempool_fix_timed_alloc); \ +CYG_LDR_TABLE_ENTRY(cyg_mempool_fix_try_alloc_entry, \ + "cyg_mempool_fix_try_alloc", \ + cyg_mempool_fix_try_alloc); \ +CYG_LDR_TABLE_ENTRY(cyg_mempool_fix_free_entry, \ + "cyg_mempool_fix_free", cyg_mempool_fix_free); \ +CYG_LDR_TABLE_ENTRY(cyg_mempool_fix_waiting_entry, \ + "cyg_mempool_fix_waiting", cyg_mempool_fix_waiting); \ +CYG_LDR_TABLE_ENTRY(cyg_mempool_fix_get_info_entry, \ + "cyg_mempool_fix_get_info", cyg_mempool_fix_get_info); -#define CYG_LDR_TABLE_KAPI_MEMPOOL_VAR() \ -CYG_LDR_TABLE_ENTRY( cyg_mempool_var_create_entry, \ - "cyg_mempool_var_create", cyg_mempool_var_create ); \ -CYG_LDR_TABLE_ENTRY( cyg_mempool_var_delete_entry, \ - "cyg_mempool_var_delete", cyg_mempool_var_delete ); \ -CYG_LDR_TABLE_ENTRY( cyg_mempool_var_alloc_entry, \ - "cyg_mempool_var_alloc", cyg_mempool_var_alloc ); \ -CYG_LDR_TABLE_ENTRY( cyg_mempool_var_timed_alloc_entry, \ - "cyg_mempool_var_timed_alloc", \ - cyg_mempool_var_timed_alloc ); \ -CYG_LDR_TABLE_ENTRY( cyg_mempool_var_try_alloc_entry, \ - "cyg_mempool_var_try_alloc", \ - cyg_mempool_var_try_alloc ); \ -CYG_LDR_TABLE_ENTRY( cyg_mempool_var_free_entry, \ - "cyg_mempool_var_free", cyg_mempool_var_free ); \ -CYG_LDR_TABLE_ENTRY( cyg_mempool_var_waiting_entry, \ - "cyg_mempool_var_waiting", cyg_mempool_var_waiting ); \ -CYG_LDR_TABLE_ENTRY( cyg_mempool_var_get_info_entry, \ - "cyg_mempool_var_get_info", cyg_mempool_var_get_info ); +#define CYG_LDR_TABLE_KAPI_MEMPOOL_VAR() \ +CYG_LDR_TABLE_ENTRY(cyg_mempool_var_create_entry, \ + "cyg_mempool_var_create", cyg_mempool_var_create); \ +CYG_LDR_TABLE_ENTRY(cyg_mempool_var_delete_entry, \ + "cyg_mempool_var_delete", cyg_mempool_var_delete); \ +CYG_LDR_TABLE_ENTRY(cyg_mempool_var_alloc_entry, \ + "cyg_mempool_var_alloc", cyg_mempool_var_alloc); \ +CYG_LDR_TABLE_ENTRY(cyg_mempool_var_timed_alloc_entry, \ + "cyg_mempool_var_timed_alloc", \ + cyg_mempool_var_timed_alloc); \ +CYG_LDR_TABLE_ENTRY(cyg_mempool_var_try_alloc_entry, \ + "cyg_mempool_var_try_alloc", \ + cyg_mempool_var_try_alloc); \ +CYG_LDR_TABLE_ENTRY(cyg_mempool_var_free_entry, \ + "cyg_mempool_var_free", cyg_mempool_var_free); \ +CYG_LDR_TABLE_ENTRY(cyg_mempool_var_waiting_entry, \ + "cyg_mempool_var_waiting", cyg_mempool_var_waiting); \ +CYG_LDR_TABLE_ENTRY(cyg_mempool_var_get_info_entry, \ + "cyg_mempool_var_get_info", cyg_mempool_var_get_info); -#define CYG_LDR_TABLE_KAPI_MUTEX() \ -CYG_LDR_TABLE_ENTRY( cyg_mutex_init_entry, \ - "cyg_mutex_init", cyg_mutex_init ); \ -CYG_LDR_TABLE_ENTRY( cyg_mutex_destroy_entry, \ - "cyg_mutex_destroy", cyg_mutex_destroy ); \ -CYG_LDR_TABLE_ENTRY( cyg_mutex_trylock_entry, \ - "cyg_mutex_trylock", cyg_mutex_trylock ); \ -CYG_LDR_TABLE_ENTRY( cyg_mutex_unlock_entry, \ - "cyg_mutex_unlock", cyg_mutex_unlock ); \ -CYG_LDR_TABLE_ENTRY( cyg_mutex_release_entry, \ - "cyg_mutex_release", cyg_mutex_release ); \ -CYG_LDR_TABLE_ENTRY( cyg_mutex_set_ceiling_entry, \ - "cyg_mutex_set_ceiling", cyg_mutex_set_ceiling ); \ -CYG_LDR_TABLE_ENTRY( cyg_mutex_set_protocol_entry, \ - "cyg_mutex_set_protocol", cyg_mutex_set_protocol ); +#define CYG_LDR_TABLE_KAPI_MUTEX() \ +CYG_LDR_TABLE_ENTRY(cyg_mutex_init_entry, \ + "cyg_mutex_init", cyg_mutex_init); \ +CYG_LDR_TABLE_ENTRY(cyg_mutex_destroy_entry, \ + "cyg_mutex_destroy", cyg_mutex_destroy); \ +CYG_LDR_TABLE_ENTRY(cyg_mutex_trylock_entry, \ + "cyg_mutex_trylock", cyg_mutex_trylock); \ +CYG_LDR_TABLE_ENTRY(cyg_mutex_unlock_entry, \ + "cyg_mutex_unlock", cyg_mutex_unlock); \ +CYG_LDR_TABLE_ENTRY(cyg_mutex_release_entry, \ + "cyg_mutex_release", cyg_mutex_release); \ +CYG_LDR_TABLE_ENTRY(cyg_mutex_set_ceiling_entry, \ + "cyg_mutex_set_ceiling", cyg_mutex_set_ceiling); \ +CYG_LDR_TABLE_ENTRY(cyg_mutex_set_protocol_entry, \ + "cyg_mutex_set_protocol", cyg_mutex_set_protocol); -#define CYG_LDR_TABLE_KAPI_SCHEDULER() \ -CYG_LDR_TABLE_ENTRY( cyg_scheduler_start_entry, \ - "cyg_scheduler_start", cyg_scheduler_start ); \ -CYG_LDR_TABLE_ENTRY( cyg_scheduler_lock_entry, \ - "cyg_scheduler_lock", cyg_scheduler_lock ); \ -CYG_LDR_TABLE_ENTRY( cyg_scheduler_safe_lock_entry, \ - "cyg_scheduler_safe_lock", cyg_scheduler_safe_lock ); \ -CYG_LDR_TABLE_ENTRY( cyg_scheduler_unlock_entry, \ - "cyg_scheduler_unlock", cyg_scheduler_unlock ); \ -CYG_LDR_TABLE_ENTRY( cyg_scheduler_read_lock_entry, \ - "cyg_scheduler_read_lock", cyg_scheduler_read_lock ); \ +#define CYG_LDR_TABLE_KAPI_SCHEDULER() \ +CYG_LDR_TABLE_ENTRY(cyg_scheduler_start_entry, \ + "cyg_scheduler_start", cyg_scheduler_start); \ +CYG_LDR_TABLE_ENTRY(cyg_scheduler_lock_entry, \ + "cyg_scheduler_lock", cyg_scheduler_lock); \ +CYG_LDR_TABLE_ENTRY(cyg_scheduler_safe_lock_entry, \ + "cyg_scheduler_safe_lock", cyg_scheduler_safe_lock); \ +CYG_LDR_TABLE_ENTRY(cyg_scheduler_unlock_entry, \ + "cyg_scheduler_unlock", cyg_scheduler_unlock); \ +CYG_LDR_TABLE_ENTRY(cyg_scheduler_read_lock_entry, \ + "cyg_scheduler_read_lock", cyg_scheduler_read_lock); \ -#define CYG_LDR_TABLE_KAPI_SEMAPHORE() \ -CYG_LDR_TABLE_ENTRY( cyg_semaphore_init_entry, \ - "cyg_semaphore_init", cyg_semaphore_init ); \ -CYG_LDR_TABLE_ENTRY( cyg_semaphore_destroy_entry, \ - "cyg_semaphore_destroy", cyg_semaphore_destroy ); \ -CYG_LDR_TABLE_ENTRY( cyg_semaphore_wait_entry, \ - "cyg_semaphore_wait", cyg_semaphore_wait ); \ -CYG_LDR_TABLE_ENTRY( cyg_semaphore_timed_wait_entry, \ - "cyg_semaphore_timed_wait", cyg_semaphore_timed_wait ); \ -CYG_LDR_TABLE_ENTRY( cyg_semaphore_try_wait_entry, \ - "cyg_semaphore_trywait", cyg_semaphore_trywait ); \ -CYG_LDR_TABLE_ENTRY( cyg_semaphore_post_entry, \ - "cyg_semaphore_post", cyg_semaphore_post ); \ -CYG_LDR_TABLE_ENTRY( cyg_semaphore_peek_entry, \ - "cyg_semaphore_peek", cyg_semaphore_peek ); +#define CYG_LDR_TABLE_KAPI_SEMAPHORE() \ +CYG_LDR_TABLE_ENTRY(cyg_semaphore_init_entry, \ + "cyg_semaphore_init", cyg_semaphore_init); \ +CYG_LDR_TABLE_ENTRY(cyg_semaphore_destroy_entry, \ + "cyg_semaphore_destroy", cyg_semaphore_destroy); \ +CYG_LDR_TABLE_ENTRY(cyg_semaphore_wait_entry, \ + "cyg_semaphore_wait", cyg_semaphore_wait); \ +CYG_LDR_TABLE_ENTRY(cyg_semaphore_timed_wait_entry, \ + "cyg_semaphore_timed_wait", cyg_semaphore_timed_wait); \ +CYG_LDR_TABLE_ENTRY(cyg_semaphore_try_wait_entry, \ + "cyg_semaphore_trywait", cyg_semaphore_trywait); \ +CYG_LDR_TABLE_ENTRY(cyg_semaphore_post_entry, \ + "cyg_semaphore_post", cyg_semaphore_post); \ +CYG_LDR_TABLE_ENTRY(cyg_semaphore_peek_entry, \ + "cyg_semaphore_peek", cyg_semaphore_peek); -#define CYG_LDR_TABLE_KAPI_THREAD() \ -CYG_LDR_TABLE_ENTRY( cyg_thread_create_entry, \ - "cyg_thread_create", cyg_thread_create ); \ -CYG_LDR_TABLE_ENTRY( cyg_thread_exit_entry, \ - "cyg_thread_exit", cyg_thread_exit ); \ -CYG_LDR_TABLE_ENTRY( cyg_thread_delete_entry, \ - "cyg_thread_delete", cyg_thread_delete ); \ -CYG_LDR_TABLE_ENTRY( cyg_thread_suspend_entry, \ - "cyg_thread_suspend", cyg_thread_suspend ); \ -CYG_LDR_TABLE_ENTRY( cyg_thread_resume_entry, \ - "cyg_thread_resume", cyg_thread_resume ); \ -CYG_LDR_TABLE_ENTRY( cyg_thread_kill_entry, \ - "cyg_thread_kill", cyg_thread_kill ); \ -CYG_LDR_TABLE_ENTRY( cyg_thread_release_entry, \ - "cyg_thread_release", cyg_thread_release ); \ -CYG_LDR_TABLE_ENTRY( cyg_thread_yield_entry, \ - "cyg_thread_yield", cyg_thread_yield ); \ -CYG_LDR_TABLE_ENTRY( cyg_thread_self_entry, \ - "cyg_thread_self", cyg_thread_self ); \ -CYG_LDR_TABLE_ENTRY( cyg_thread_idle_thread_entry, \ - "cyg_thread_idle_thread", cyg_thread_idle_thread ); \ -CYG_LDR_TABLE_ENTRY( cyg_thread_set_priority_entry, \ - "cyg_thread_set_priority", cyg_thread_set_priority ); \ -CYG_LDR_TABLE_ENTRY( cyg_thread_get_priority_entry, \ - "cyg_thread_get_priority", cyg_thread_get_priority ); \ -CYG_LDR_TABLE_ENTRY( cyg_thread_get_current_priority_entry, \ - "cyg_thread_get_current_priority", \ - cyg_thread_get_current_priority ); \ -CYG_LDR_TABLE_ENTRY( cyg_thread_delay_entry, \ - "cyg_thread_delay", cyg_thread_delay ); \ -CYG_LDR_TABLE_ENTRY( cyg_thread_get_stack_base_entry, \ - "cyg_thread_get_stack_base", cyg_thread_get_stack_base ); \ -CYG_LDR_TABLE_ENTRY( cyg_thread_get_stack_size_entry, \ - "cyg_thread_get_stack_size", cyg_thread_get_stack_size ); \ -CYG_LDR_TABLE_ENTRY( cyg_thread_new_data_index_entry, \ - "cyg_thread_new_data_index", cyg_thread_new_data_index ); \ -CYG_LDR_TABLE_ENTRY( cyg_thread_free_data_index_entry, \ - "cyg_thread_free_data_index", \ - cyg_thread_free_data_index ); \ -CYG_LDR_TABLE_ENTRY( cyg_thread_get_data_entry, \ - "cyg_thread_get_data", cyg_thread_get_data ); \ -CYG_LDR_TABLE_ENTRY( cyg_thread_get_data_ptr_entry, \ - "cyg_thread_get_data_ptr", cyg_thread_get_data_ptr ); \ -CYG_LDR_TABLE_ENTRY( cyg_thread_set_data_entry, \ - "cyg_thread_set_data", cyg_thread_set_data ); +#define CYG_LDR_TABLE_KAPI_THREAD() \ +CYG_LDR_TABLE_ENTRY(cyg_thread_create_entry, \ + "cyg_thread_create", cyg_thread_create); \ +CYG_LDR_TABLE_ENTRY(cyg_thread_exit_entry, \ + "cyg_thread_exit", cyg_thread_exit); \ +CYG_LDR_TABLE_ENTRY(cyg_thread_delete_entry, \ + "cyg_thread_delete", cyg_thread_delete); \ +CYG_LDR_TABLE_ENTRY(cyg_thread_suspend_entry, \ + "cyg_thread_suspend", cyg_thread_suspend); \ +CYG_LDR_TABLE_ENTRY(cyg_thread_resume_entry, \ + "cyg_thread_resume", cyg_thread_resume); \ +CYG_LDR_TABLE_ENTRY(cyg_thread_kill_entry, \ + "cyg_thread_kill", cyg_thread_kill); \ +CYG_LDR_TABLE_ENTRY(cyg_thread_release_entry, \ + "cyg_thread_release", cyg_thread_release); \ +CYG_LDR_TABLE_ENTRY(cyg_thread_yield_entry, \ + "cyg_thread_yield", cyg_thread_yield); \ +CYG_LDR_TABLE_ENTRY(cyg_thread_self_entry, \ + "cyg_thread_self", cyg_thread_self); \ +CYG_LDR_TABLE_ENTRY(cyg_thread_idle_thread_entry, \ + "cyg_thread_idle_thread", cyg_thread_idle_thread); \ +CYG_LDR_TABLE_ENTRY(cyg_thread_set_priority_entry, \ + "cyg_thread_set_priority", cyg_thread_set_priority); \ +CYG_LDR_TABLE_ENTRY(cyg_thread_get_priority_entry, \ + "cyg_thread_get_priority", cyg_thread_get_priority); \ +CYG_LDR_TABLE_ENTRY(cyg_thread_get_current_priority_entry, \ + "cyg_thread_get_current_priority", \ + cyg_thread_get_current_priority); \ +CYG_LDR_TABLE_ENTRY(cyg_thread_delay_entry, \ + "cyg_thread_delay", cyg_thread_delay); \ +CYG_LDR_TABLE_ENTRY(cyg_thread_get_stack_base_entry, \ + "cyg_thread_get_stack_base", cyg_thread_get_stack_base); \ +CYG_LDR_TABLE_ENTRY(cyg_thread_get_stack_size_entry, \ + "cyg_thread_get_stack_size", cyg_thread_get_stack_size); \ +CYG_LDR_TABLE_ENTRY(cyg_thread_new_data_index_entry, \ + "cyg_thread_new_data_index", cyg_thread_new_data_index); \ +CYG_LDR_TABLE_ENTRY(cyg_thread_free_data_index_entry, \ + "cyg_thread_free_data_index", \ + cyg_thread_free_data_index); \ +CYG_LDR_TABLE_ENTRY(cyg_thread_get_data_entry, \ + "cyg_thread_get_data", cyg_thread_get_data); \ +CYG_LDR_TABLE_ENTRY(cyg_thread_get_data_ptr_entry, \ + "cyg_thread_get_data_ptr", cyg_thread_get_data_ptr); \ +CYG_LDR_TABLE_ENTRY(cyg_thread_set_data_entry, \ + "cyg_thread_set_data", cyg_thread_set_data); -#define CYG_LDR_TABLE_STRING() \ -CYG_LDR_TABLE_ENTRY( memchr_entry, "memchr", memchr ); \ -CYG_LDR_TABLE_ENTRY( memcmp_entry, "memcmp", memcmp ); \ -CYG_LDR_TABLE_ENTRY( memcpy_entry, "memcpy", memcpy ); \ -CYG_LDR_TABLE_ENTRY( memmove_entry, "memmove", memmove ); \ -CYG_LDR_TABLE_ENTRY( memset_entry, "memset", memset ); \ -CYG_LDR_TABLE_ENTRY( strcpy_entry, "strcpy", strcpy ); \ -CYG_LDR_TABLE_ENTRY( strncpy_entry, "strncpy", strncpy ); \ -CYG_LDR_TABLE_ENTRY( strcat_entry, "strcat", strcat ); \ -CYG_LDR_TABLE_ENTRY( strncat_entry, "strncat", strncat ); \ -CYG_LDR_TABLE_ENTRY( strchr_entry, "strchr", strchr ); \ -CYG_LDR_TABLE_ENTRY( strrchr_entry, "strrchr", strrchr ); \ -CYG_LDR_TABLE_ENTRY( strcoll_entry, "strcoll", strcoll ); \ -CYG_LDR_TABLE_ENTRY( strlen_entry, "strlen", strlen ); \ -CYG_LDR_TABLE_ENTRY( strcmp_entry, "strcmp", strcmp ); \ -CYG_LDR_TABLE_ENTRY( strncmp_entry, "strncmp", strncmp ); \ -CYG_LDR_TABLE_ENTRY( strcspn_entry, "strcspn", strcspn ); \ -CYG_LDR_TABLE_ENTRY( strerror_entry, "strerror", strerror ); \ -CYG_LDR_TABLE_ENTRY( strpbrk_entry, "strpbrk", strpbrk ); \ -CYG_LDR_TABLE_ENTRY( strspn_entry, "strspn", strspn ); \ -CYG_LDR_TABLE_ENTRY( strstr_entry, "strstr", strstr ); \ -CYG_LDR_TABLE_ENTRY( strtok_entry, "strtok", strtok ); \ -CYG_LDR_TABLE_ENTRY( strxfrm_entry, "strxfrm", strxfrm ); +#define CYG_LDR_TABLE_STRING() \ +CYG_LDR_TABLE_ENTRY(memchr_entry, "memchr", memchr); \ +CYG_LDR_TABLE_ENTRY(memcmp_entry, "memcmp", memcmp); \ +CYG_LDR_TABLE_ENTRY(memcpy_entry, "memcpy", memcpy); \ +CYG_LDR_TABLE_ENTRY(memmove_entry, "memmove", memmove); \ +CYG_LDR_TABLE_ENTRY(memset_entry, "memset", memset); \ +CYG_LDR_TABLE_ENTRY(strcpy_entry, "strcpy", strcpy); \ +CYG_LDR_TABLE_ENTRY(strncpy_entry, "strncpy", strncpy); \ +CYG_LDR_TABLE_ENTRY(strcat_entry, "strcat", strcat); \ +CYG_LDR_TABLE_ENTRY(strncat_entry, "strncat", strncat); \ +CYG_LDR_TABLE_ENTRY(strchr_entry, "strchr", strchr); \ +CYG_LDR_TABLE_ENTRY(strrchr_entry, "strrchr", strrchr); \ +CYG_LDR_TABLE_ENTRY(strcoll_entry, "strcoll", strcoll); \ +CYG_LDR_TABLE_ENTRY(strlen_entry, "strlen", strlen); \ +CYG_LDR_TABLE_ENTRY(strcmp_entry, "strcmp", strcmp); \ +CYG_LDR_TABLE_ENTRY(strncmp_entry, "strncmp", strncmp); \ +CYG_LDR_TABLE_ENTRY(strcspn_entry, "strcspn", strcspn); \ +CYG_LDR_TABLE_ENTRY(strerror_entry, "strerror", strerror); \ +CYG_LDR_TABLE_ENTRY(strpbrk_entry, "strpbrk", strpbrk); \ +CYG_LDR_TABLE_ENTRY(strspn_entry, "strspn", strspn); \ +CYG_LDR_TABLE_ENTRY(strstr_entry, "strstr", strstr); \ +CYG_LDR_TABLE_ENTRY(strtok_entry, "strtok", strtok); \ +CYG_LDR_TABLE_ENTRY(strxfrm_entry, "strxfrm", strxfrm); -#define CYG_LDR_TABLE_STDIO() \ -CYG_LDR_TABLE_ENTRY( clearerr_entry, "clearerr", clearerr ); \ -CYG_LDR_TABLE_ENTRY( fclose_entry, "fclose", fclose ); \ -CYG_LDR_TABLE_ENTRY( feof_entry, "feof", feof ); \ -CYG_LDR_TABLE_ENTRY( ferror_entry, "ferror", ferror ); \ -CYG_LDR_TABLE_ENTRY( fflush_entry, "fflush", fflush ); \ -CYG_LDR_TABLE_ENTRY( fgetc_entry, "fgetc", fgetc ); \ -CYG_LDR_TABLE_ENTRY( fgetpos_entry, "fgetpos", fgetpos ); \ -CYG_LDR_TABLE_ENTRY( fgets_entry, "fgets", fgets ); \ -CYG_LDR_TABLE_ENTRY( fopen_entry, "fopen", fopen ); \ -CYG_LDR_TABLE_ENTRY( fprintf_entry, "fprintf", fprintf ); \ -CYG_LDR_TABLE_ENTRY( fputc_entry, "fputc", fputc ); \ -CYG_LDR_TABLE_ENTRY( fputs_entry, "fputs", fputs ); \ -CYG_LDR_TABLE_ENTRY( fread_entry, "fread", fread ); \ -CYG_LDR_TABLE_ENTRY( freopen_entry, "freopen", freopen ); \ -CYG_LDR_TABLE_ENTRY( fscanf_entry, "fscanf", fscanf ); \ -CYG_LDR_TABLE_ENTRY( fseek_entry, "fseek", fseek ); \ -CYG_LDR_TABLE_ENTRY( fsetpos_entry, "fsetpos", fsetpos ); \ -CYG_LDR_TABLE_ENTRY( ftell_entry, "ftell", ftell ); \ -CYG_LDR_TABLE_ENTRY( fwrite_entry, "fwrite", fwrite ); \ -CYG_LDR_TABLE_ENTRY( perror_entry, "perror", perror ); \ -CYG_LDR_TABLE_ENTRY( printf_entry, "printf", printf ); \ -CYG_LDR_TABLE_ENTRY( putc_entry, "putc", putc ); \ -CYG_LDR_TABLE_ENTRY( putchar_entry, "putchar", putchar ); \ -CYG_LDR_TABLE_ENTRY( puts_entry, "puts", puts ); \ -CYG_LDR_TABLE_ENTRY( remove_entry, "remove", remove ); \ -CYG_LDR_TABLE_ENTRY( rename_entry, "rename", rename ); \ -CYG_LDR_TABLE_ENTRY( rewind_entry, "rewind", rewind ); \ -CYG_LDR_TABLE_ENTRY( scanf_entry, "scanf", scanf ); \ -CYG_LDR_TABLE_ENTRY( setbuf_entry, "setbuf", setbuf ); \ -CYG_LDR_TABLE_ENTRY( setvbuf_entry, "setvbuf", setvbuf ); \ -CYG_LDR_TABLE_ENTRY( sprintf_entry, "sprintf", sprintf ); \ -CYG_LDR_TABLE_ENTRY( sscanf_entry, "sscanf", sscanf ); \ -CYG_LDR_TABLE_ENTRY( tmpfile_entry, "tmpfile", tmpfile ); \ -CYG_LDR_TABLE_ENTRY( tmpnam_entry, "tmpnam", tmpnam ); \ -CYG_LDR_TABLE_ENTRY( ungetc_entry, "ungetc", ungetc ); +#define CYG_LDR_TABLE_STDIO() \ +CYG_LDR_TABLE_ENTRY(clearerr_entry, "clearerr", clearerr); \ +CYG_LDR_TABLE_ENTRY(fclose_entry, "fclose", fclose); \ +CYG_LDR_TABLE_ENTRY(feof_entry, "feof", feof); \ +CYG_LDR_TABLE_ENTRY(ferror_entry, "ferror", ferror); \ +CYG_LDR_TABLE_ENTRY(fflush_entry, "fflush", fflush); \ +CYG_LDR_TABLE_ENTRY(fgetc_entry, "fgetc", fgetc); \ +CYG_LDR_TABLE_ENTRY(fgetpos_entry, "fgetpos", fgetpos); \ +CYG_LDR_TABLE_ENTRY(fgets_entry, "fgets", fgets); \ +CYG_LDR_TABLE_ENTRY(fopen_entry, "fopen", fopen); \ +CYG_LDR_TABLE_ENTRY(fprintf_entry, "fprintf", fprintf); \ +CYG_LDR_TABLE_ENTRY(fputc_entry, "fputc", fputc); \ +CYG_LDR_TABLE_ENTRY(fputs_entry, "fputs", fputs); \ +CYG_LDR_TABLE_ENTRY(fread_entry, "fread", fread); \ +CYG_LDR_TABLE_ENTRY(freopen_entry, "freopen", freopen); \ +CYG_LDR_TABLE_ENTRY(fscanf_entry, "fscanf", fscanf); \ +CYG_LDR_TABLE_ENTRY(fseek_entry, "fseek", fseek); \ +CYG_LDR_TABLE_ENTRY(fsetpos_entry, "fsetpos", fsetpos); \ +CYG_LDR_TABLE_ENTRY(ftell_entry, "ftell", ftell); \ +CYG_LDR_TABLE_ENTRY(fwrite_entry, "fwrite", fwrite); \ +CYG_LDR_TABLE_ENTRY(perror_entry, "perror", perror); \ +CYG_LDR_TABLE_ENTRY(printf_entry, "printf", printf); \ +CYG_LDR_TABLE_ENTRY(putc_entry, "putc", putc); \ +CYG_LDR_TABLE_ENTRY(putchar_entry, "putchar", putchar); \ +CYG_LDR_TABLE_ENTRY(puts_entry, "puts", puts); \ +CYG_LDR_TABLE_ENTRY(remove_entry, "remove", remove); \ +CYG_LDR_TABLE_ENTRY(rename_entry, "rename", rename); \ +CYG_LDR_TABLE_ENTRY(rewind_entry, "rewind", rewind); \ +CYG_LDR_TABLE_ENTRY(scanf_entry, "scanf", scanf); \ +CYG_LDR_TABLE_ENTRY(setbuf_entry, "setbuf", setbuf); \ +CYG_LDR_TABLE_ENTRY(setvbuf_entry, "setvbuf", setvbuf); \ +CYG_LDR_TABLE_ENTRY(sprintf_entry, "sprintf", sprintf); \ +CYG_LDR_TABLE_ENTRY(sscanf_entry, "sscanf", sscanf); \ +CYG_LDR_TABLE_ENTRY(tmpfile_entry, "tmpfile", tmpfile); \ +CYG_LDR_TABLE_ENTRY(tmpnam_entry, "tmpnam", tmpnam); \ +CYG_LDR_TABLE_ENTRY(ungetc_entry, "ungetc", ungetc); -#define CYG_LDR_TABLE_INFRA_DIAG() \ -CYG_LDR_TABLE_ENTRY( diag_init_entry, "diag_init", diag_init ); \ -CYG_LDR_TABLE_ENTRY( diag_write_char_entry, \ - "diag_write_char", diag_write_char ); \ -CYG_LDR_TABLE_ENTRY( diag_write_string_entry, \ - "diag_write_string", diag_write_string ); \ -CYG_LDR_TABLE_ENTRY( diag_write_dec_entry, \ - "diag_write_dec", diag_write_dec ); \ -CYG_LDR_TABLE_ENTRY( diag_write_hex_entry, \ - "diag_write_hex", diag_write_hex ); \ -CYG_LDR_TABLE_ENTRY( diag_dump_buf_entry, \ - "diag_dump_buf", diag_dump_buf ); \ -CYG_LDR_TABLE_ENTRY( diag_dump_buf_32bit_entry, \ - "diag_dump_buf_32bit", diag_dump_buf_32bit ); \ -CYG_LDR_TABLE_ENTRY( diag_dump_buf_16bit_entry, \ - "diag_dump_buf_16bit", diag_dump_buf_16bit ); \ -CYG_LDR_TABLE_ENTRY( diag_vdump_buf_with_offset_entry, \ - "diag_vdump_buf_with_offset", \ - diag_vdump_buf_with_offset ); \ -CYG_LDR_TABLE_ENTRY( diag_dump_buf_with_offset_entry, \ - "diag_dump_buf_with_offset", \ - diag_dump_buf_with_offset ); \ -CYG_LDR_TABLE_ENTRY( diag_dump_buf_with_offset_32bit_entry, \ - "diag_dump_buf_with_offset_32bit", \ - diag_dump_buf_with_offset_32bit ); \ -CYG_LDR_TABLE_ENTRY( diag_dump_buf_with_offset_16bit_entry, \ - "diag_dump_buf_with_offset_16bit", \ - diag_dump_buf_with_offset_16bit ); \ -CYG_LDR_TABLE_ENTRY( diag_printf_entry, "diag_printf", diag_printf ); \ -CYG_LDR_TABLE_ENTRY( diag_init_putc_entry, "diag_init_putc", diag_init_putc ); \ -CYG_LDR_TABLE_ENTRY( diag_sprintf_entry, "diag_sprintf", diag_sprintf ); \ -CYG_LDR_TABLE_ENTRY( diag_snprintf_entry, "diag_snprintf", diag_snprintf ); \ -CYG_LDR_TABLE_ENTRY( diag_vsprintf_entry, "diag_vsprintf", diag_vsprintf ); \ -CYG_LDR_TABLE_ENTRY( diag_vprintf_entry, "diag_vprintf", diag_vprintf ); +#define CYG_LDR_TABLE_INFRA_DIAG() \ +CYG_LDR_TABLE_ENTRY(diag_init_entry, "diag_init", diag_init); \ +CYG_LDR_TABLE_ENTRY(diag_write_char_entry, \ + "diag_write_char", diag_write_char); \ +CYG_LDR_TABLE_ENTRY(diag_write_string_entry, \ + "diag_write_string", diag_write_string); \ +CYG_LDR_TABLE_ENTRY(diag_write_dec_entry, \ + "diag_write_dec", diag_write_dec); \ +CYG_LDR_TABLE_ENTRY(diag_write_hex_entry, \ + "diag_write_hex", diag_write_hex); \ +CYG_LDR_TABLE_ENTRY(diag_dump_buf_entry, \ + "diag_dump_buf", diag_dump_buf); \ +CYG_LDR_TABLE_ENTRY(diag_dump_buf_32bit_entry, \ + "diag_dump_buf_32bit", diag_dump_buf_32bit); \ +CYG_LDR_TABLE_ENTRY(diag_dump_buf_16bit_entry, \ + "diag_dump_buf_16bit", diag_dump_buf_16bit); \ +CYG_LDR_TABLE_ENTRY(diag_vdump_buf_with_offset_entry, \ + "diag_vdump_buf_with_offset", \ + diag_vdump_buf_with_offset); \ +CYG_LDR_TABLE_ENTRY(diag_dump_buf_with_offset_entry, \ + "diag_dump_buf_with_offset", \ + diag_dump_buf_with_offset); \ +CYG_LDR_TABLE_ENTRY(diag_dump_buf_with_offset_32bit_entry, \ + "diag_dump_buf_with_offset_32bit", \ + diag_dump_buf_with_offset_32bit); \ +CYG_LDR_TABLE_ENTRY(diag_dump_buf_with_offset_16bit_entry, \ + "diag_dump_buf_with_offset_16bit", \ + diag_dump_buf_with_offset_16bit); \ +CYG_LDR_TABLE_ENTRY(diag_printf_entry, "diag_printf", diag_printf); \ +CYG_LDR_TABLE_ENTRY(diag_init_putc_entry, "diag_init_putc", diag_init_putc); \ +CYG_LDR_TABLE_ENTRY(diag_sprintf_entry, "diag_sprintf", diag_sprintf); \ +CYG_LDR_TABLE_ENTRY(diag_snprintf_entry, "diag_snprintf", diag_snprintf); \ +CYG_LDR_TABLE_ENTRY(diag_vsprintf_entry, "diag_vsprintf", diag_vsprintf); \ +CYG_LDR_TABLE_ENTRY(diag_vprintf_entry, "diag_vprintf", diag_vprintf); //============================================================================== #endif
--- a/packages/services/objloader/current/include/relocate_i386.h +++ b/packages/services/objloader/current/include/relocate_i386.h @@ -62,10 +62,10 @@ #define ELF_ARCH_ENDIANNESS ELFDATA2LSB #define ELF_ARCH_RELTYPE Elf_Rel -#define R_386_32 1 -#define R_386_PC32 2 +#define R_386_32 1 +#define R_386_PC32 2 -void cyg_ldr_flush_cache( void ); -cyg_int32 cyg_ldr_relocate( cyg_int32, cyg_uint32, cyg_int32 ); +void cyg_ldr_flush_cache(void); +cyg_int32 cyg_ldr_relocate(cyg_int32, cyg_uint32, cyg_int32); #endif //__RELOCATE_I386_H__
--- a/packages/services/objloader/current/include/relocate_ppc.h +++ b/packages/services/objloader/current/include/relocate_ppc.h @@ -45,7 +45,7 @@ * ================================================================= * #####DESCRIPTIONBEGIN#### * - * Author(s): atonizzo@lycos.com + * Author(s): Anthony Tonizzo (atonizzo@gmail.com) * Date: 2005-05-13 * Purpose: * Description:
--- a/packages/services/objloader/current/src/loader_fs.c +++ b/packages/services/objloader/current/src/loader_fs.c @@ -42,7 +42,7 @@ * ================================================================= * #####DESCRIPTIONBEGIN#### * - * Author(s): atonizzo@lycos.com + * Author(s): Anthony Tonizzo (atonizzo@gmail.com) * Contributors: nickg@ecoscentric.com * Date: 2005-05-13 * Purpose: @@ -66,46 +66,43 @@ #include <cyg/objloader/loader_fs.h> size_t -cyg_ldr_fs_read( PELF_OBJECT p, size_t s, size_t n, void *mem ) +cyg_ldr_fs_read(PELF_OBJECT p, size_t s, size_t n, void *mem) { - return fread( mem, s, n, (FILE*)p->ptr ); -} - -cyg_int32 -cyg_ldr_fs_seek( PELF_OBJECT p, cyg_uint32 offs ) -{ - return fseek( (FILE*)p->ptr, offs, SEEK_SET ); + return fread(mem, s, n, (FILE*)p->ptr); } cyg_int32 -cyg_ldr_fs_close( PELF_OBJECT p ) +cyg_ldr_fs_seek(PELF_OBJECT p, cyg_uint32 offs) { - return fclose( (FILE*)p->ptr ); + return fseek((FILE*)p->ptr, offs, SEEK_SET); +} + +cyg_int32 +cyg_ldr_fs_close(PELF_OBJECT p) +{ + return fclose((FILE*)p->ptr); } PELF_OBJECT -cyg_ldr_open_library_fs( cyg_uint8 *ptr ) +cyg_ldr_open_library_fs(char *ptr) { - PELF_OBJECT e_obj; - FILE *fp; - - fp = fopen( ptr, "rb" ); - if ( fp == 0 ) + FILE *fp = fopen(ptr, "rb"); + if (fp == NULL) { cyg_ldr_last_error = "FILE NOT FOUND"; return (void*)0; } // Create a file object to keep track of this library. - e_obj = (PELF_OBJECT)malloc( sizeof( ELF_OBJECT ) ); - CYG_ASSERT( e_obj != 0, "Cannot malloc() e_obj" ); - if ( e_obj == 0 ) + PELF_OBJECT e_obj = (PELF_OBJECT)malloc(sizeof(ELF_OBJECT)); + CYG_ASSERT(e_obj != 0, "Cannot malloc() e_obj"); + if (e_obj == 0) { cyg_ldr_last_error = "ERROR IN MALLOC"; - fclose( fp ); + fclose(fp); return (void*)0; } - memset( e_obj, 0, sizeof( ELF_OBJECT ) ); + memset(e_obj, 0, sizeof(ELF_OBJECT)); e_obj->ptr = (CYG_ADDRWORD)fp; e_obj->mode = CYG_LDR_MODE_FILESYSTEM; @@ -117,7 +114,7 @@ cyg_ldr_open_library_fs( cyg_uint8 *ptr } void -cyg_ldr_close_library_fs( PELF_OBJECT p ) +cyg_ldr_close_library_fs(PELF_OBJECT p) { }
--- a/packages/services/objloader/current/src/objelf.c +++ b/packages/services/objloader/current/src/objelf.c @@ -42,7 +42,7 @@ * ================================================================= * #####DESCRIPTIONBEGIN#### * - * Author(s): atonizzo@lycos.com + * Author(s): Anthony Tonizzo (atonizzo@gmail.com) * Contributors: nickg@ecoscentric.com * Date: 2005-05-13 * Purpose: @@ -62,161 +62,161 @@ #include <cyg/objloader/elf.h> #include <cyg/objloader/objelf.h> -CYG_HAL_TABLE_BEGIN( cyg_ldr_table, ldr_table ); -CYG_HAL_TABLE_END( cyg_ldr_table_end, ldr_table ); +CYG_HAL_TABLE_BEGIN(cyg_ldr_table, ldr_table); +CYG_HAL_TABLE_END(cyg_ldr_table_end, ldr_table); __externC cyg_ldr_table_entry cyg_ldr_table[]; __externC cyg_ldr_table_entry cyg_ldr_table_end[]; #if CYGPKG_SERVICES_OBJLOADER_DEBUG_LEVEL > 0 void -cyg_ldr_print_section_data( PELF_OBJECT p ) +cyg_ldr_print_section_data(PELF_OBJECT p) { - cyg_int32 i; - cyg_uint8 strname[32]; - cyg_uint8 *p_strtab = (cyg_uint8*)p->sections[p->p_elfhdr->e_shstrndx]; + int i; + char strname[32]; + char *p_strtab = (char*)p->sections[p->p_elfhdr->e_shstrndx]; - diag_printf( "\n\nSection Headers:\n" ); - diag_printf( "[Nr] Name Addr Offset Size Info\n" ); - for ( i = 0; i < p->p_elfhdr->e_shnum; i++ ) + diag_printf("\n\nSection Headers:\n"); + diag_printf("[Nr] Name Addr Offset Size Info\n"); + for (i = 0; i < p->p_elfhdr->e_shnum; i++) { - sprintf( strname, "%s", p_strtab + p->p_sechdr[i].sh_name ); - while ( strlen( strname ) < 20 ) - strcat( strname, " " ); - diag_printf( "[%02d] %s %08X %08X %08X %08X\n", + sprintf(strname, "%s", p_strtab + p->p_sechdr[i].sh_name); + while (strlen(strname) < 20) + strcat(strname, " "); + diag_printf("[%02d] %s %08X %08X %08X %08X\n", i, strname, p->p_sechdr[i].sh_addr, p->p_sechdr[i].sh_offset, p->p_sechdr[i].sh_size, - p->p_sechdr[i].sh_info ); + p->p_sechdr[i].sh_info); } - diag_printf( "\n" ); + diag_printf("\n"); } void -cyg_ldr_print_symbol_names( PELF_OBJECT p ) +cyg_ldr_print_symbol_names(PELF_OBJECT p) { - cyg_int32 i, symtab_entries; + int i; Elf32_Sym *p_symtab = (Elf32_Sym*)p->sections[p->hdrndx_symtab]; - cyg_uint8 *p_strtab = (cyg_uint8*)p->sections[p->hdrndx_strtab]; - cyg_uint8 strname[32]; + char *p_strtab = (char*)p->sections[p->hdrndx_strtab]; + char strname[32]; // Total number of entries in the symbol table. - symtab_entries = p->p_sechdr[p->hdrndx_symtab].sh_size / + int symtab_entries = p->p_sechdr[p->hdrndx_symtab].sh_size / p->p_sechdr[p->hdrndx_symtab].sh_entsize; - diag_printf( "Num Value Size Ndx Name\n" ); - for ( i = 1; i < symtab_entries; i++ ) + diag_printf("Num Value Size Ndx Name\n"); + for (i = 1; i < symtab_entries; i++) { - sprintf( strname, "%d", i ); - while ( strlen( strname ) < 5 ) - strcat( strname, " " ); - diag_printf( strname ); + sprintf(strname, "%d", i); + while (strlen(strname) < 5) + strcat(strname, " "); + diag_printf(strname); - sprintf( strname, + sprintf(strname, "%08X %d", p_symtab[i].st_value, - p_symtab[i].st_size ); - while ( strlen( strname ) < 15 ) - strcat( strname, " " ); - diag_printf( strname ); + p_symtab[i].st_size); + while (strlen(strname) < 15) + strcat(strname, " "); + diag_printf(strname); - sprintf( strname, "%d", p_symtab[i].st_shndx ); - while ( strlen( strname ) < 6 ) - strcat( strname, " " ); - diag_printf( strname ); + sprintf(strname, "%d", p_symtab[i].st_shndx); + while (strlen(strname) < 6) + strcat(strname, " "); + diag_printf(strname); - strncpy( strname, + strncpy(strname, p_strtab + p_symtab[i].st_name, - sizeof( strname ) - 1 ); - strname[strlen( p_strtab + p_symtab[i].st_name )] = '\0'; - diag_printf( strname ); - diag_printf( "\n" ); + sizeof(strname) - 1); + strname[strlen(p_strtab + p_symtab[i].st_name)] = '\0'; + diag_printf(strname); + diag_printf("\n"); } } void -cyg_ldr_print_rel_names( PELF_OBJECT p ) +cyg_ldr_print_rel_names(PELF_OBJECT p) { - cyg_int32 i, j, r_entries, sym_index; + int i, j, r_entries, sym_index; Elf32_Sym *p_symtab = (Elf32_Sym*)p->sections[p->hdrndx_symtab]; - cyg_uint8 *p_strtab = (cyg_uint8*)p->sections[p->hdrndx_strtab]; - cyg_uint8 *p_shstrtab = (cyg_uint8*)p->sections[p->p_elfhdr->e_shstrndx]; + char *p_strtab = (char*)p->sections[p->hdrndx_strtab]; + char *p_shstrtab = (char*)p->sections[p->p_elfhdr->e_shstrndx]; #if ELF_ARCH_RELTYPE == Elf_Rela Elf32_Rela* p_rela; #else Elf32_Rel* p_rel; #endif - cyg_uint8 strname[32]; + char strname[32]; - for ( i = 1; i < p->p_elfhdr->e_shnum; i++ ) + for (i = 1; i < p->p_elfhdr->e_shnum; i++) { - if ( ( p->p_sechdr[i].sh_type == SHT_REL ) || - ( p->p_sechdr[i].sh_type == SHT_RELA ) ) + if ((p->p_sechdr[i].sh_type == SHT_REL) || + (p->p_sechdr[i].sh_type == SHT_RELA)) { // Calculate the total number of entries in the .rela section. r_entries = p->p_sechdr[i].sh_size / p->p_sechdr[i].sh_entsize; - diag_printf( "\n\nSymbols at: %s\n\n", - p_shstrtab + p->p_sechdr[i].sh_name ); + diag_printf("\n\nSymbols at: %s\n\n", + p_shstrtab + p->p_sechdr[i].sh_name); #if ELF_ARCH_RELTYPE == Elf_Rela - p_rela = (Elf32_Rela*)cyg_ldr_load_elf_section( p, i ); - printf( "Offset Info Name [+ Addend]\n" ); + p_rela = (Elf32_Rela*)cyg_ldr_load_elf_section(p, i); + printf("Offset Info Name [+ Addend]\n"); #else - p_rel = (Elf32_Rel*)cyg_ldr_load_elf_section( p, i ); - printf( "Offset Info Name\n" ); + p_rel = (Elf32_Rel*)cyg_ldr_load_elf_section(p, i); + printf("Offset Info Name\n"); #endif - for ( j = 0; j < r_entries; j++ ) + for (j = 0; j < r_entries; j++) { - sprintf( strname, + sprintf(strname, "%08X %08X ", #if ELF_ARCH_RELTYPE == Elf_Rela - p_rela[j].r_offset, - p_rela[j].r_info + p_rela[j].r_offset, + p_rela[j].r_info #else - p_rel[j].r_offset, - p_rel[j].r_info + p_rel[j].r_offset, + p_rel[j].r_info #endif - ); + ); - diag_printf( strname ); + diag_printf(strname); #if ELF_ARCH_RELTYPE == Elf_Rela - cyg_uint8 sym_type = ELF32_R_SYM( p_rela[j].r_info ); + cyg_uint8 sym_type = ELF32_R_SYM(p_rela[j].r_info); #else - cyg_uint8 sym_type = ELF32_R_SYM( p_rel[j].r_info ); + cyg_uint8 sym_type = ELF32_R_SYM(p_rel[j].r_info); #endif - if ( strlen ( p_strtab + p_symtab[sym_type].st_name ) > 0 ) - diag_printf( p_strtab + p_symtab[sym_type].st_name ); + if (strlen (p_strtab + p_symtab[sym_type].st_name) > 0) + diag_printf(p_strtab + p_symtab[sym_type].st_name); else { // If the symbol name is not available, then print // the name of the section. sym_index = p_symtab[sym_type].st_shndx; - diag_printf( p_shstrtab + p->p_sechdr[sym_index].sh_name ); + diag_printf(p_shstrtab + p->p_sechdr[sym_index].sh_name); } #if ELF_ARCH_RELTYPE == Elf_Rela - if ( p_rela[j].r_addend != 0 ) - diag_printf( " + %08X", p_rela[j].r_addend ); + if (p_rela[j].r_addend != 0) + diag_printf(" + %08X", p_rela[j].r_addend); #endif - diag_printf( "\n" ); + diag_printf("\n"); } // After all the printing is done, the relocation table can // be dumped. - cyg_ldr_delete_elf_section( p, i ); + cyg_ldr_delete_elf_section(p, i); } } } #endif // DEBUG_PRINT static void -*cyg_ldr_local_address( PELF_OBJECT p, cyg_uint32 sym_index ) +*cyg_ldr_local_address(PELF_OBJECT p, cyg_uint32 sym_index) { cyg_uint32 data_sec, addr; Elf32_Sym *p_symtab; - p_symtab = (Elf32_Sym*)cyg_ldr_section_address( p, p->hdrndx_symtab ); + p_symtab = (Elf32_Sym*)cyg_ldr_section_address(p, p->hdrndx_symtab); // Find out the section number in which the data for this symbol is // located. @@ -224,14 +224,14 @@ static void // From the section number we get the start of the memory area in // memory. - addr = (cyg_uint32)cyg_ldr_section_address( p, data_sec ); + addr = (cyg_uint32)cyg_ldr_section_address(p, data_sec); // And now return the address of the data. - return (void*)( addr + p_symtab[sym_index].st_value); + return (void*)(addr + p_symtab[sym_index].st_value); } void -*cyg_ldr_external_address( PELF_OBJECT p, cyg_uint32 sym_index ) +*cyg_ldr_external_address(PELF_OBJECT p, cyg_uint32 sym_index) { cyg_uint8* tmp2; Elf32_Sym *p_symtab; @@ -239,14 +239,14 @@ void cyg_ldr_table_entry *entry = cyg_ldr_table; - p_symtab = (Elf32_Sym*)cyg_ldr_section_address( p, p->hdrndx_symtab ); - p_strtab = (cyg_uint8*)cyg_ldr_section_address( p, p->hdrndx_strtab ); + p_symtab = (Elf32_Sym*)cyg_ldr_section_address(p, p->hdrndx_symtab); + p_strtab = (cyg_uint8*)cyg_ldr_section_address(p, p->hdrndx_strtab); // This is the name of the external reference to search. tmp2 = p_strtab + p_symtab[sym_index].st_name; - while ( entry != cyg_ldr_table_end ) + while (entry != cyg_ldr_table_end) { - if ( !strcmp( (const char*)tmp2, entry->symbol_name ) ) + if (!strcmp((const char*)tmp2, entry->symbol_name )) return entry->handler; entry++; } @@ -263,42 +263,38 @@ void // 0 : Symbol not found // Other : Address of the symbol in absolute memory. void -*cyg_ldr_symbol_address( PELF_OBJECT p, cyg_uint32 sym_index ) +*cyg_ldr_symbol_address(PELF_OBJECT p, cyg_uint32 sym_index) { cyg_uint32 addr; - cyg_uint8 sym_info; - Elf32_Sym *p_symtab; - - p_symtab = (Elf32_Sym*)cyg_ldr_section_address( p, p->hdrndx_symtab ); - sym_info = p_symtab[sym_index].st_info; - - switch ( ELF32_ST_TYPE( sym_info ) ) + Elf32_Sym *p_symtab = (Elf32_Sym*)cyg_ldr_section_address(p, + p->hdrndx_symtab); + cyg_uint8 sym_info = p_symtab[sym_index].st_info; + switch (ELF32_ST_TYPE(sym_info)) { case STT_NOTYPE: case STT_FUNC: case STT_OBJECT: - switch ( ELF32_ST_BIND( sym_info ) ) + switch (ELF32_ST_BIND(sym_info)) { case STB_LOCAL: case STB_GLOBAL: - if ( p_symtab[sym_index].st_shndx == SHN_UNDEF ) - return cyg_ldr_external_address( p, sym_index ); + if (p_symtab[sym_index].st_shndx == SHN_UNDEF) + return cyg_ldr_external_address(p, sym_index); else - return cyg_ldr_local_address( p, sym_index ); + return cyg_ldr_local_address(p, sym_index); case STB_WEAK: - addr = (cyg_uint32)cyg_ldr_external_address( p, sym_index ); - if ( addr != 0 ) + addr = (cyg_uint32)cyg_ldr_external_address(p, sym_index); + if (addr != 0) return (void*)addr; else - return cyg_ldr_local_address( p, sym_index ); + return cyg_ldr_local_address(p, sym_index); default: return 0; } break; case STT_SECTION: // Return the starting address of a section, given its index. - return (void*)cyg_ldr_section_address( p, - p_symtab[sym_index].st_shndx ); + return (void*)cyg_ldr_section_address(p, p_symtab[sym_index].st_shndx); default: return 0; } @@ -307,64 +303,60 @@ void // Loads the relocation information, relocates, and dumps the relocation // information once the process is complete. cyg_int32 -cyg_ldr_relocate_section( PELF_OBJECT p, cyg_uint32 r_shndx ) +cyg_ldr_relocate_section(PELF_OBJECT p, cyg_uint32 r_shndx) { - cyg_int32 i, rc; - cyg_uint32 r_entries, r_target_shndx, r_target_addr; - cyg_uint32 sym_value, sym_index; - Elf32_Addr r_offset; - Elf32_Word r_type; - Elf32_Sword r_addend; + int i, rc; #if ELF_ARCH_RELTYPE == Elf_Rela - Elf32_Rela* p_rela = (Elf32_Rela*)cyg_ldr_load_elf_section( p, r_shndx ); + Elf32_Rela* p_rela = (Elf32_Rela*)cyg_ldr_load_elf_section(p, r_shndx); #else - Elf32_Rel* p_rel = (Elf32_Rel*)cyg_ldr_load_elf_section( p, r_shndx ); + Elf32_Rel* p_rel = (Elf32_Rel*)cyg_ldr_load_elf_section(p, r_shndx); #endif #if CYGPKG_SERVICES_OBJLOADER_DEBUG_LEVEL > 0 - Elf32_Sym *p_symtab = (Elf32_Sym*)cyg_ldr_section_address( p, - p->hdrndx_symtab ); - cyg_uint8 *p_strtab = (cyg_uint8*)cyg_ldr_section_address( p, - p->hdrndx_strtab ); - cyg_uint8 *p_shstrtab = (cyg_uint8*)cyg_ldr_section_address( p, - p->p_elfhdr->e_shstrndx ); + Elf32_Sym *p_symtab = (Elf32_Sym*)cyg_ldr_section_address(p, + p->hdrndx_symtab); + char *p_strtab = (char*)cyg_ldr_section_address(p, p->hdrndx_strtab); + char *p_shstrtab = (char*)cyg_ldr_section_address(p, + p->p_elfhdr->e_shstrndx); #endif // Now we can get the address of the contents of the section to modify. - r_target_shndx = p->p_sechdr[r_shndx].sh_info; - r_target_addr = (cyg_uint32)cyg_ldr_section_address( p, r_target_shndx ); + cyg_uint32 r_target_shndx = p->p_sechdr[r_shndx].sh_info; + cyg_uint32 r_target_addr = (cyg_uint32)cyg_ldr_section_address(p, + r_target_shndx); #if CYGPKG_SERVICES_OBJLOADER_DEBUG_LEVEL > 0 - diag_printf( "Relocating section \"%s\"\n", - p_shstrtab + p->p_sechdr[r_target_shndx].sh_name ); + diag_printf("Relocating section \"%s\"\n", + p_shstrtab + p->p_sechdr[r_target_shndx].sh_name); #if CYGPKG_SERVICES_OBJLOADER_DEBUG_LEVEL > 1 - diag_printf( "Ndx Type Offset Name\"\n" ); + diag_printf("Ndx Type Offset Name\"\n"); #endif #endif // Perform relocatation for each of the members of this table. - r_entries = p->p_sechdr[r_shndx].sh_size / p->p_sechdr[r_shndx].sh_entsize; - for ( i = 0; i < r_entries; i++ ) + cyg_uint32 r_entries = p->p_sechdr[r_shndx].sh_size / + p->p_sechdr[r_shndx].sh_entsize; + for (i = 0; i < r_entries; i++) { #if ELF_ARCH_RELTYPE == Elf_Rela - r_offset = p_rela[i].r_offset; - r_type = ELF32_R_TYPE( p_rela[i].r_info ); - sym_index = ELF32_R_SYM( p_rela[i].r_info ); - r_addend = p_rela[i].r_addend; + Elf32_Addr r_offset = p_rela[i].r_offset; + Elf32_Word r_type = ELF32_R_TYPE(p_rela[i].r_info); + cyg_uint32 sym_index = ELF32_R_SYM(p_rela[i].r_info); + Elf32_Sword r_addend = p_rela[i].r_addend; #else - r_offset = p_rel[i].r_offset; - r_type = ELF32_R_TYPE( p_rel[i].r_info ); - sym_index = ELF32_R_SYM( p_rel[i].r_info ); - r_addend = 0; + Elf32_Addr r_offset = p_rel[i].r_offset; + Elf32_Word r_type = ELF32_R_TYPE(p_rel[i].r_info); + cyg_uint32 sym_index = ELF32_R_SYM(p_rel[i].r_info); + Elf32_Sword r_addend = 0; #endif - sym_value = (cyg_uint32)cyg_ldr_symbol_address( p, sym_index ); - if ( sym_value == 0 ) + cyg_uint32 sym_value = (cyg_uint32)cyg_ldr_symbol_address(p, sym_index); + if (sym_value == 0) { #if CYGPKG_SERVICES_OBJLOADER_DEBUG_LEVEL > 0 - diag_printf( "Unknown symbol value: %s Index: %d\n", + diag_printf("Unknown symbol value: %s Index: %d\n", p_strtab + p_symtab[sym_index].st_name, - sym_index ); + sym_index); #endif return -1; } @@ -372,36 +364,36 @@ cyg_ldr_relocate_section( PELF_OBJECT p, // This is architecture dependent, and deals with whether we have // '.rel' or '.rela' sections. #if CYGPKG_SERVICES_OBJLOADER_DEBUG_LEVEL > 1 - diag_printf( "%04X %04X %08X ", + diag_printf("%04X %04X %08X ", sym_index, r_type, - r_offset ); - if ( strlen ( p_strtab + p_symtab[sym_index].st_name ) > 0 ) - diag_printf( p_strtab + p_symtab[sym_index].st_name ); + r_offset); + if (strlen(p_strtab + p_symtab[sym_index].st_name) > 0) + diag_printf(p_strtab + p_symtab[sym_index].st_name); else { // If the symbol name is not available, then print // the name of the section. cyg_uint32 sec_ndx = p_symtab[sym_index].st_shndx; - diag_printf( p_shstrtab + p->p_sechdr[sec_ndx].sh_name ); + diag_printf(p_shstrtab + p->p_sechdr[sec_ndx].sh_name); } - diag_printf( "\n" ); + diag_printf("\n"); #endif - rc = cyg_ldr_relocate( r_type, + rc = cyg_ldr_relocate(r_type, r_target_addr + r_offset, - sym_value + r_addend ); - if ( rc != 0 ) + sym_value + r_addend); + if (rc != 0) { #if CYGPKG_SERVICES_OBJLOADER_DEBUG_LEVEL > 0 - diag_printf( "Relocation error: Cannot find symbol: %s\n", - p_strtab + p_symtab[sym_index].st_name ); + diag_printf("Relocation error: Cannot find symbol: %s\n", + p_strtab + p_symtab[sym_index].st_name); #endif return -1; } } // After the relocation is done, the relocation table can be dumped. - cyg_ldr_delete_elf_section( p, r_shndx ); + cyg_ldr_delete_elf_section(p, r_shndx); return 0; }
--- a/packages/services/objloader/current/src/objloader.c +++ b/packages/services/objloader/current/src/objloader.c @@ -42,7 +42,7 @@ * ================================================================= * #####DESCRIPTIONBEGIN#### * - * Author(s): atonizzo@lycos.com + * Author(s): Anthony Tonizzo (atonizzo@gmail.com) * Contributors: nickg@ecoscentric.com * Date: 2005-05-13 * Purpose: @@ -64,26 +64,26 @@ #include <cyg/objloader/objelf.h> #include <cyg/objloader/loader_fs.h> -cyg_uint8 *cyg_ldr_last_error; +char *cyg_ldr_last_error; -void *cyg_ldr_malloc( size_t ) CYGBLD_ATTRIB_WEAK; +void *cyg_ldr_malloc(size_t) CYGBLD_ATTRIB_WEAK; void -*cyg_ldr_malloc( size_t s ) +*cyg_ldr_malloc(size_t s) { - return malloc( s ); + return malloc(s); } -void cyg_ldr_free( void * ) CYGBLD_ATTRIB_WEAK; +void cyg_ldr_free(void *) CYGBLD_ATTRIB_WEAK; void -cyg_ldr_free( void *s ) +cyg_ldr_free(void *s) { - free( s ); + free(s); } void -cyg_ldr_delete_elf_section( PELF_OBJECT p, cyg_uint32 idx ) +cyg_ldr_delete_elf_section(PELF_OBJECT p, cyg_uint32 idx) { - cyg_ldr_free( p->sections[idx] ); + cyg_ldr_free(p->sections[idx]); p->sections[idx] = 0; } @@ -91,102 +91,99 @@ cyg_ldr_delete_elf_section( PELF_OBJECT // the close() function to close files or sockets, and finally frees up // the ELF object altogether. static void -cyg_ldr_free_elf_object( PELF_OBJECT p ) +cyg_ldr_free_elf_object(PELF_OBJECT p) { cyg_int32 i; - for ( i = 0; i < p->p_elfhdr->e_shnum + 1; i++ ) - if ( p->sections[i] ) - cyg_ldr_delete_elf_section( p, i ); + for (i = 0; i < p->p_elfhdr->e_shnum + 1; i++) + if (p->sections[i]) + cyg_ldr_delete_elf_section(p, i); - if ( p->sections != 0 ) - cyg_ldr_free( p->sections ); + if (p->sections != 0) + cyg_ldr_free(p->sections); - if ( p->p_sechdr != 0 ) - cyg_ldr_free( p->p_sechdr ); + if (p->p_sechdr != 0) + cyg_ldr_free(p->p_sechdr); - if ( p->p_elfhdr != 0 ) - cyg_ldr_free( p->p_elfhdr ); + if (p->p_elfhdr != 0) + cyg_ldr_free(p->p_elfhdr); - p->close( p ); - cyg_ldr_free( p ); + p->close(p); + cyg_ldr_free(p); } static cyg_uint32 -cyg_ldr_find_common_size( PELF_OBJECT p ) +cyg_ldr_find_common_size(PELF_OBJECT p) { - cyg_int32 i, symtab_entries, common_size = 0; + cyg_int32 i, common_size = 0; Elf32_Sym *p_symtab = (Elf32_Sym*)p->sections[p->hdrndx_symtab]; // Total number of entries in the symbol table. - symtab_entries = p->p_sechdr[p->hdrndx_symtab].sh_size / + int symtab_entries = p->p_sechdr[p->hdrndx_symtab].sh_size / p->p_sechdr[p->hdrndx_symtab].sh_entsize; - for ( i = 1; i < symtab_entries; i++ ) - if ( p_symtab[i].st_shndx == SHN_COMMON ) + for (i = 1; i < symtab_entries; i++) + if (p_symtab[i].st_shndx == SHN_COMMON) { // In the case of an SHN_COMMON symbol the st_value field holds // alignment constraints. cyg_uint32 boundary = p_symtab[i].st_value - 1; // Calculate the next byte boundary. - common_size = ( common_size + boundary ) & ~boundary; + common_size = (common_size + boundary) & ~boundary; common_size += p_symtab[i].st_size; } #if CYGPKG_SERVICES_OBJLOADER_DEBUG_LEVEL > 0 - diag_printf( "common_size = %d\n", common_size ); + diag_printf("common_size = %d\n", common_size); #endif return common_size; } // Allocates memory and loads the contents of a specific ELF section. // Returns the address of the newly allocated memory, of 0 for any error. -cyg_int32 -*cyg_ldr_load_elf_section( PELF_OBJECT p, cyg_uint32 idx ) +cyg_uint32 +*cyg_ldr_load_elf_section(PELF_OBJECT p, cyg_uint32 idx) { - cyg_uint32 *addr; - - addr = cyg_ldr_malloc( p->p_sechdr[idx].sh_size ); - CYG_ASSERT( addr != 0, "Cannot malloc() section" ); - if ( addr == 0 ) + cyg_uint32 *addr = (cyg_uint32 *)cyg_ldr_malloc(p->p_sechdr[idx].sh_size); + CYG_ASSERT(addr != 0, "Cannot malloc() section"); + if (addr == 0) { cyg_ldr_last_error = "ERROR IN MALLOC"; return (void*)0; } - p->seek( p, p->p_sechdr[idx].sh_offset ); - p->read( p, sizeof( char ), p->p_sechdr[idx].sh_size, addr ); + p->seek(p, p->p_sechdr[idx].sh_offset); + p->read(p, sizeof(char), p->p_sechdr[idx].sh_size, addr); return addr; } // Returns the starting address of a section. If the section is not already // loaded in memory, area for it will be allocated and the section will be // loaded. -cyg_int32 -*cyg_ldr_section_address( PELF_OBJECT p, cyg_uint32 idx ) +cyg_uint32 +*cyg_ldr_section_address(PELF_OBJECT p, cyg_uint32 idx) { - if ( p->sections[idx] == 0 ) - p->sections[idx] = cyg_ldr_load_elf_section( p, idx ); + if (p->sections[idx] == 0) + p->sections[idx] = cyg_ldr_load_elf_section(p, idx); return p->sections[idx]; } void -*cyg_ldr_find_symbol( void* handle, cyg_uint8* sym_name ) +*cyg_ldr_find_symbol(void* handle, char* sym_name) { PELF_OBJECT p = (PELF_OBJECT)handle; - cyg_uint8* tmp2; - cyg_int32 i, symtab_entries; - cyg_uint8 *p_strtab = (cyg_uint8*)p->sections[p->hdrndx_strtab]; + int i; + char *p_strtab = (char*)p->sections[p->hdrndx_strtab]; Elf32_Sym *p_symtab = (Elf32_Sym*)p->sections[p->hdrndx_symtab]; - - symtab_entries = p->p_sechdr[p->hdrndx_symtab].sh_size / + + int symtab_entries = p->p_sechdr[p->hdrndx_symtab].sh_size / p->p_sechdr[p->hdrndx_symtab].sh_entsize; - for ( i = 0; i < symtab_entries; i++ ) + for (i = 0; i < symtab_entries; i++) { - tmp2 = p_strtab + p_symtab[i].st_name; - if ( !strcmp( tmp2, sym_name ) ) - return cyg_ldr_symbol_address( p, i ); + char* tmp2 = p_strtab + p_symtab[i].st_name; + if (!strcmp(tmp2, sym_name)) + return cyg_ldr_symbol_address(p, i); } // Symbol not found. @@ -194,25 +191,25 @@ void return 0; } -static cyg_uint8 -*cyg_ldr_sanity_check( PELF_OBJECT p ) +static char +*cyg_ldr_sanity_check(PELF_OBJECT p) { - if ( ( p->p_elfhdr->e_ident[EI_MAG0] != ELFMAG0 ) || - ( p->p_elfhdr->e_ident[EI_MAG1] != ELFMAG1 ) || - ( p->p_elfhdr->e_ident[EI_MAG2] != ELFMAG2 ) || - ( p->p_elfhdr->e_ident[EI_MAG3] != ELFMAG3 ) || - ( p->p_elfhdr->e_ident[EI_CLASS] != ELFCLASS32 ) ) + if ((p->p_elfhdr->e_ident[EI_MAG0] != ELFMAG0) || + (p->p_elfhdr->e_ident[EI_MAG1] != ELFMAG1) || + (p->p_elfhdr->e_ident[EI_MAG2] != ELFMAG2 ) || + (p->p_elfhdr->e_ident[EI_MAG3] != ELFMAG3) || + (p->p_elfhdr->e_ident[EI_CLASS] != ELFCLASS32)) return "INVALID ELF HEADER"; // We only work with relocatable files. No dynamic linking. - if ( p->p_elfhdr->e_type != ET_REL ) + if (p->p_elfhdr->e_type != ET_REL) return "NOT RELOCATABLE"; // These #defines are sitting in the hal. - if ( p->p_elfhdr->e_machine != ELF_ARCH_MACHINE_TYPE ) + if (p->p_elfhdr->e_machine != ELF_ARCH_MACHINE_TYPE) return "INVALID ARCHITECTURE"; - if ( p->p_elfhdr->e_ident[EI_DATA] != ELF_ARCH_ENDIANNESS ) + if (p->p_elfhdr->e_ident[EI_DATA] != ELF_ARCH_ENDIANNESS) return "INVALID ENDIAN"; return 0; } @@ -221,20 +218,20 @@ static cyg_uint8 // will be loaded on demand when needed during the relocation process and, // when possible, dumped after use. static cyg_int32 -cyg_ldr_load_sections( PELF_OBJECT p ) +cyg_ldr_load_sections(PELF_OBJECT p) { - cyg_uint8 *error_string; + char *error_string; cyg_int32 idx; // Load the ELF header. - p->p_elfhdr = (Elf32_Ehdr*)cyg_ldr_malloc( sizeof( Elf32_Ehdr ) ); - CYG_ASSERT( p->p_elfhdr != 0, "Cannot malloc() p->p_elfhdr" ); - if ( p->p_elfhdr == 0 ) + p->p_elfhdr = (Elf32_Ehdr*)cyg_ldr_malloc(sizeof(Elf32_Ehdr)); + CYG_ASSERT(p->p_elfhdr != 0, "Cannot malloc() p->p_elfhdr"); + if (p->p_elfhdr == 0) return -1; - p->seek( p, 0 ); - p->read( p, sizeof( char ), sizeof( Elf32_Ehdr ), p->p_elfhdr ); - error_string = cyg_ldr_sanity_check( p ); - if ( error_string != 0 ) + p->seek(p, 0); + p->read(p, sizeof(char), sizeof(Elf32_Ehdr), p->p_elfhdr ); + error_string = cyg_ldr_sanity_check(p); + if (error_string != 0) { cyg_ldr_last_error = "ERROR IN ELF HEADER"; return -1; @@ -244,84 +241,79 @@ cyg_ldr_load_sections( PELF_OBJECT p ) // library. This is not strictly optimal, since some sections do not // need to be loaded all the time. Allocate an extra pointer for the // COMMON area. - p->sections = cyg_ldr_malloc( ( p->p_elfhdr->e_shnum + 1 ) * - sizeof( cyg_uint32 ) ); - CYG_ASSERT( p->sections != 0, "Cannot malloc() p->sections" ); - if ( p->sections == 0 ) - { - cyg_ldr_last_error = "ERROR IN MALLOC"; - return -1; - } - memset( p->sections, 0, ( p->p_elfhdr->e_shnum + 1 ) * - sizeof( cyg_uint32 ) ); - - // Now that the header is loaded, load the sections header. - p->p_sechdr = (Elf32_Shdr*)cyg_ldr_malloc( - p->p_elfhdr->e_shnum * p->p_elfhdr->e_shentsize ); - CYG_ASSERT( p->p_sechdr != 0, "Cannot malloc() p->p_sechdr" ); - if ( p->p_sechdr == 0 ) + p->sections = cyg_ldr_malloc((p->p_elfhdr->e_shnum + 1) * + sizeof(cyg_uint32)); + CYG_ASSERT(p->sections != 0, "Cannot malloc() p->sections"); + if (p->sections == 0) { cyg_ldr_last_error = "ERROR IN MALLOC"; return -1; } - p->seek( p, p->p_elfhdr->e_shoff ); - p->read( p, p->p_elfhdr->e_shentsize, p->p_elfhdr->e_shnum, p->p_sechdr ); + memset(p->sections, 0, (p->p_elfhdr->e_shnum + 1) * + sizeof(cyg_uint32)); + + // Now that the header is loaded, load the sections header. + p->p_sechdr = (Elf32_Shdr*)cyg_ldr_malloc( + p->p_elfhdr->e_shnum * p->p_elfhdr->e_shentsize); + CYG_ASSERT(p->p_sechdr != 0, "Cannot malloc() p->p_sechdr"); + if (p->p_sechdr == 0) + { + cyg_ldr_last_error = "ERROR IN MALLOC"; + return -1; + } + p->seek(p, p->p_elfhdr->e_shoff); + p->read(p, p->p_elfhdr->e_shentsize, p->p_elfhdr->e_shnum, p->p_sechdr); // Load the section header string table. This is a byte oriented table, // so alignment is not an issue. idx = p->p_elfhdr->e_shstrndx; - p->sections[idx] = cyg_ldr_load_elf_section( p, idx ); + p->sections[idx] = cyg_ldr_load_elf_section(p, idx); return 0; } PELF_OBJECT -cyg_ldr_open_library( CYG_ADDRWORD ptr, cyg_int32 mode ) +cyg_ldr_open_library(CYG_ADDRWORD ptr, cyg_int32 mode) { - Elf32_Sym *p_symtab; - cyg_uint8 *p_shstrtab; - PELF_OBJECT e_obj; int (*fn)(void); - cyg_int32 i, rc, symtab_entries; - cyg_uint32 common_size; + int i; // In the future there might be a switch() (against 'mode') that calls an // open function other than cyg_ldr_open_library_fs(). These function // fetch and open a library using ftp, http or libraries that are already // in ROM. - e_obj = cyg_ldr_open_library_fs( (cyg_uint8*)ptr ); - if ( e_obj == 0 ) + PELF_OBJECT e_obj = cyg_ldr_open_library_fs((char*)ptr); + if (e_obj == 0) return 0; - rc = cyg_ldr_load_sections( e_obj ); - if ( rc != 0 ) + int rc = cyg_ldr_load_sections(e_obj); + if (rc != 0) { - cyg_ldr_free_elf_object( e_obj ); + cyg_ldr_free_elf_object(e_obj); return 0; } // Find the section index for the .shstrtab section. The names of the // sections are held here, and are the only way to identify them. - p_shstrtab = (cyg_uint8*)cyg_ldr_section_address( e_obj, - e_obj->p_elfhdr->e_shstrndx ); - if ( p_shstrtab == 0 ) + char *p_shstrtab = (char*)cyg_ldr_section_address(e_obj, + e_obj->p_elfhdr->e_shstrndx); + if (p_shstrtab == 0) { - cyg_ldr_free_elf_object( e_obj ); + cyg_ldr_free_elf_object(e_obj); return 0; } // .symtab section and .strtab. We have to go through the section names // to find where they are. - for ( i = 1; i < e_obj->p_elfhdr->e_shnum; i++ ) + for (i = 1; i < e_obj->p_elfhdr->e_shnum; i++) { // Now look for the index of .symtab. These are the symbols needed for // the symbol retrieval as well as relocation. - if ( !strcmp( p_shstrtab + e_obj->p_sechdr[i].sh_name, - ELF_STRING_symtab ) ) + if (!strcmp(p_shstrtab + e_obj->p_sechdr[i].sh_name, ELF_STRING_symtab)) { e_obj->hdrndx_symtab = i; - e_obj->sections[i] = cyg_ldr_load_elf_section( e_obj, i ); - if ( e_obj->sections[i] == 0 ) + e_obj->sections[i] = cyg_ldr_load_elf_section(e_obj, i); + if (e_obj->sections[i] == 0) { - cyg_ldr_free_elf_object( e_obj ); + cyg_ldr_free_elf_object(e_obj); return 0; } } @@ -329,21 +321,20 @@ cyg_ldr_open_library( CYG_ADDRWORD ptr, // Load the table with the names of all the symbols. We need this // to compare the name of external references symbols against the // names in the in the CYG_HAL_TABLE provided by the user. - if ( !strcmp( p_shstrtab + e_obj->p_sechdr[i].sh_name, - ELF_STRING_strtab ) ) + if (!strcmp(p_shstrtab + e_obj->p_sechdr[i].sh_name, ELF_STRING_strtab)) { e_obj->hdrndx_strtab = i; - e_obj->sections[i] = cyg_ldr_load_elf_section( e_obj, i ); - if ( e_obj->sections[i] == 0 ) + e_obj->sections[i] = cyg_ldr_load_elf_section(e_obj, i); + if (e_obj->sections[i] == 0) { - cyg_ldr_free_elf_object( e_obj ); + cyg_ldr_free_elf_object(e_obj); return 0; } } } - CYG_ASSERT( e_obj->hdrndx_symtab != 0, "No symtab index found" ); - CYG_ASSERT( e_obj->hdrndx_strtab != 0, "No strtab index found" ); + CYG_ASSERT(e_obj->hdrndx_symtab != 0, "No symtab index found"); + CYG_ASSERT(e_obj->hdrndx_strtab != 0, "No strtab index found"); // Now look for symbols in the COMMON area. The COMMON symbols are a // special case, because the area they reside in must be sized up @@ -351,79 +342,79 @@ cyg_ldr_open_library( CYG_ADDRWORD ptr, // the sections header and can be read out of the library itself. // Extra room in the 'sections' array has already been allocated to hold // the pointer to the commons area. - common_size = cyg_ldr_find_common_size( e_obj ); - if ( common_size != 0 ) + cyg_uint32 common_size = cyg_ldr_find_common_size(e_obj); + if (common_size != 0) { cyg_uint32 com_shndx = e_obj->p_elfhdr->e_shnum; cyg_int32 com_offset = 0; - e_obj->sections[com_shndx] = (cyg_uint32*)cyg_ldr_malloc( common_size ); - CYG_ASSERT( e_obj->sections[com_shndx] != 0, - "Cannot malloc() the COMMONS" ); + e_obj->sections[com_shndx] = (cyg_uint32*)cyg_ldr_malloc(common_size); + CYG_ASSERT(e_obj->sections[com_shndx] != 0, + "Cannot malloc() the COMMONS"); - if ( e_obj->sections[com_shndx] == 0 ) + if (e_obj->sections[com_shndx] == 0) { - cyg_ldr_free_elf_object( e_obj ); + cyg_ldr_free_elf_object(e_obj); return 0; } // Now find all the symbols in the SHN_COMMON area and make // them point to the newly allocated COM area. - symtab_entries = e_obj->p_sechdr[e_obj->hdrndx_symtab].sh_size / + int symtab_entries = e_obj->p_sechdr[e_obj->hdrndx_symtab].sh_size / e_obj->p_sechdr[e_obj->hdrndx_symtab].sh_entsize; - p_symtab = (Elf32_Sym*)e_obj->sections[e_obj->hdrndx_symtab]; + Elf32_Sym *p_symtab = (Elf32_Sym*)e_obj->sections[e_obj->hdrndx_symtab]; #if CYGPKG_SERVICES_OBJLOADER_DEBUG_LEVEL > 1 - diag_printf( "Num Value Size Ndx Name\n" ); + diag_printf("Num Value Size Ndx Name\n"); #endif - for ( i = 1; i < symtab_entries; i++ ) + for (i = 1; i < symtab_entries; i++) { #if CYGPKG_SERVICES_OBJLOADER_DEBUG_LEVEL > 1 - cyg_uint8 *p_strtab = (cyg_uint8*)cyg_ldr_section_address( e_obj, - e_obj->hdrndx_strtab ); + cyg_uint8 *p_strtab = (cyg_uint8*)cyg_ldr_section_address(e_obj, + e_obj->hdrndx_strtab); #endif - if ( p_symtab[i].st_shndx == SHN_COMMON ) + if (p_symtab[i].st_shndx == SHN_COMMON) { cyg_uint32 boundary = p_symtab[i].st_value - 1; // Calculate the next byte boundary. - com_offset = ( com_offset + boundary ) & ~boundary; + com_offset = (com_offset + boundary) & ~boundary; p_symtab[i].st_shndx = com_shndx; p_symtab[i].st_value = com_offset; com_offset += p_symtab[i].st_size; } #if CYGPKG_SERVICES_OBJLOADER_DEBUG_LEVEL > 1 - diag_printf( "%03d %08X %04X %03d %s\n", + diag_printf("%03d %08X %04X %03d %s\n", i, p_symtab[i].st_value, p_symtab[i].st_size, p_symtab[i].st_shndx, - p_strtab + p_symtab[i].st_name ); + p_strtab + p_symtab[i].st_name); #endif } } #if CYGPKG_SERVICES_OBJLOADER_DEBUG_LEVEL > 0 - cyg_ldr_print_section_data( e_obj ); + cyg_ldr_print_section_data(e_obj); #if CYGPKG_SERVICES_OBJLOADER_DEBUG_LEVEL > 1 - cyg_ldr_print_symbol_names( e_obj ); + cyg_ldr_print_symbol_names(e_obj); #endif #endif - for ( i = 1; i < e_obj->p_elfhdr->e_shnum; i++ ) + for (i = 1; i < e_obj->p_elfhdr->e_shnum; i++) { // Find all the '.rel' or '.rela' sections and relocate them. - if ( ( e_obj->p_sechdr[i].sh_type == SHT_REL ) || - ( e_obj->p_sechdr[i].sh_type == SHT_RELA ) ) + if ((e_obj->p_sechdr[i].sh_type == SHT_REL) || + (e_obj->p_sechdr[i].sh_type == SHT_RELA)) { // Load and relocate the section. - rc = cyg_ldr_relocate_section( e_obj, i ); - if ( rc < 0 ) + rc = cyg_ldr_relocate_section(e_obj, i); + if (rc < 0) { #if CYGPKG_SERVICES_OBJLOADER_DEBUG_LEVEL > 0 - ELFDEBUG( "Relocation unsuccessful\n" ); + ELFDEBUG("Relocation unsuccessful\n"); #endif - cyg_ldr_free_elf_object( e_obj ); + cyg_ldr_free_elf_object(e_obj); return 0; } } @@ -433,30 +424,30 @@ cyg_ldr_open_library( CYG_ADDRWORD ptr, cyg_ldr_flush_cache(); // Run the library initialization code. - fn = cyg_ldr_find_symbol( e_obj, "library_open" ); - if ( fn != 0 ) + fn = cyg_ldr_find_symbol(e_obj, "library_open"); + if (fn != 0) fn(); return ((void*)e_obj); } -cyg_uint8 -*cyg_ldr_error( void ) +char +*cyg_ldr_error(void) { - cyg_uint8* p = cyg_ldr_last_error; + char* p = cyg_ldr_last_error; cyg_ldr_last_error = NULL; return p; } -void cyg_ldr_close_library( void* handle ) +void cyg_ldr_close_library(void* handle) { void (*fn)(void); PELF_OBJECT p = (PELF_OBJECT)handle; - fn = cyg_ldr_find_symbol( p, "library_close" ); - if ( fn != 0 ) + fn = cyg_ldr_find_symbol(p, "library_close"); + if (fn != 0) fn(); - cyg_ldr_free_elf_object( p ); + cyg_ldr_free_elf_object(p); p = 0; }
--- a/packages/services/objloader/current/src/relocate_i386.c +++ b/packages/services/objloader/current/src/relocate_i386.c @@ -43,7 +43,7 @@ * ================================================================= * #####DESCRIPTIONBEGIN#### * - * Author(s): atonizzo@lycos.com, andrew.lunn@ascom.ch + * Author(s): Anthony Tonizzo (atonizzo@gmail.com), andrew.lunn@ascom.ch * Date: 2005-07-07 * Purpose: * Description: @@ -63,7 +63,7 @@ #if defined(CYGPKG_HAL_I386) || defined(CYGPKG_HAL_SYNTH_I386) void -cyg_ldr_flush_cache( void ) +cyg_ldr_flush_cache(void) { HAL_DCACHE_SYNC(); HAL_ICACHE_SYNC(); @@ -75,23 +75,23 @@ cyg_ldr_flush_cache( void ) // mem Address in memory to modify (relocate). // sym_value cyg_int32 -cyg_ldr_relocate( cyg_int32 sym_type, cyg_uint32 mem, cyg_int32 sym_value ) +cyg_ldr_relocate(cyg_int32 sym_type, cyg_uint32 mem, cyg_int32 sym_value) { cyg_int32 i; // PPC uses rela, so we have to add the addend. - switch( sym_type ) + switch(sym_type) { case R_386_32: - HAL_READ_UINT32( mem , i ); - HAL_WRITE_UINT32( mem, i + sym_value ); + HAL_READ_UINT32(mem , i); + HAL_WRITE_UINT32(mem, i + sym_value ); return 0; case R_386_PC32: - HAL_READ_UINT32( mem , i ); - HAL_WRITE_UINT32( mem, i + sym_value - mem ); + HAL_READ_UINT32(mem , i); + HAL_WRITE_UINT32(mem, i + sym_value - mem); return 0; default: - ELFDEBUG( "FIXME: Unknown relocation value!!!\n" ); + ELFDEBUG("FIXME: Unknown relocation value!!!\n"); return -1; } }
--- a/packages/services/objloader/current/src/relocate_ppc.c +++ b/packages/services/objloader/current/src/relocate_ppc.c @@ -42,7 +42,7 @@ * ================================================================= * #####DESCRIPTIONBEGIN#### * - * Author(s): atonizzo@lycos.com + * Author(s): Anthony Tonizzo (atonizzo@gmail.com) * Date: 2005-05-13 * Purpose: * Description: @@ -67,7 +67,7 @@ #ifdef CYGPKG_HAL_POWERPC void -cyg_ldr_flush_cache( void ) +cyg_ldr_flush_cache(void) { HAL_DCACHE_SYNC(); HAL_ICACHE_SYNC(); @@ -79,38 +79,38 @@ cyg_ldr_flush_cache( void ) // mem Address in memory to modify (relocate). // sym_value cyg_int32 -cyg_ldr_relocate( cyg_int32 sym_type, cyg_uint32 mem, cyg_int32 sym_value ) +cyg_ldr_relocate(cyg_int32 sym_type, cyg_uint32 mem, cyg_int32 sym_value) { cyg_int32 rel_offset, i; // PPC uses rela, so we have to add the addend. - switch( sym_type ) + switch(sym_type) { case R_PPC_ADDR16_HA: - HAL_WRITE_UINT16( mem, _ha_( sym_value ) ); + HAL_WRITE_UINT16(mem, _ha_(sym_value)); return 0; case R_PPC_ADDR16_HI: - HAL_WRITE_UINT16( mem, _hi_( sym_value ) ); + HAL_WRITE_UINT16(mem, _hi_(sym_value)); return 0; case R_PPC_ADDR16_LO: - HAL_WRITE_UINT16( mem, _lo_( sym_value ) ); + HAL_WRITE_UINT16(mem, _lo_(sym_value)); return 0; case R_PPC_REL24: // Now it is time to seek the destination address of the call. // We need to do something in case the user jumps more than 16MB. - rel_offset = ( sym_value - mem ) & 0x03FFFFFC; - HAL_READ_UINT32( mem, i ); + rel_offset = (sym_value - mem) & 0x03FFFFFC; + HAL_READ_UINT32(mem, i); i &= 0xFC000003; - HAL_WRITE_UINT32( mem, rel_offset | i ); + HAL_WRITE_UINT32(mem, rel_offset | i); return 0; case R_PPC_REL32: - HAL_WRITE_UINT32( mem, ( sym_value - mem ) ); + HAL_WRITE_UINT32(mem, (sym_value - mem)); return 0; case R_PPC_ADDR32: - HAL_WRITE_UINT32( mem, sym_value ); + HAL_WRITE_UINT32(mem, sym_value); return 0; default: - ELFDEBUG( "FIXME: Unknown relocation value!!!\n" ); + ELFDEBUG("FIXME: Unknown relocation value!!!\n"); return -1; } }
--- a/packages/services/objloader/current/tests/library/hello.c +++ b/packages/services/objloader/current/tests/library/hello.c @@ -42,7 +42,7 @@ * ================================================================= * #####DESCRIPTIONBEGIN#### * - * Author(s): atonizzo@lycos.com + * Author(s): Anthony Tonizzo (atonizzo@gmail.com) * Date: 2005-05-13 * Purpose: * Description: @@ -61,76 +61,76 @@ int thread_a_count; extern int weak_fn_called; -void weak_function( void ) CYGBLD_ATTRIB_WEAK; -void weak_function( void ) +void weak_function(void) CYGBLD_ATTRIB_WEAK; +void weak_function(void) { // Store the data value passed in for this thread. - diag_printf( "INFO:< This is the library weak function>" ); - CYG_TEST_FAIL ( "Libraries weak function called when apps should be called" ); + diag_printf("INFO:< This is the library weak function>"); + CYG_TEST_FAIL ("Libraries weak function called when apps should be called"); } -void library_open( void ) +void library_open(void) { // Initialize the count for thread a. thread_a_count = 0; // Initialize the semaphore with a count of zero, // prior to creating the threads. - cyg_semaphore_init( &sem_signal_thread, 0 ); - CYG_TEST_INFO( "Library initialized" ); + cyg_semaphore_init(&sem_signal_thread, 0); + CYG_TEST_INFO("Library initialized"); } -void library_close( void ) +void library_close(void) { - CYG_TEST_INFO( "Library closed" ); + CYG_TEST_INFO("Library closed"); } -void print_message( void ) +void print_message(void) { - diag_printf( "INFO:<Printing a silly message...>\n" ); + diag_printf("INFO:<Printing a silly message...>\n"); } // Thread A - signals thread B via semaphore. -void thread_a( cyg_addrword_t data ) +void thread_a(cyg_addrword_t data) { // Store the data value passed in for this thread. int msg = (int)data; weak_function (); - while( thread_a_count < 5 ) + while(thread_a_count < 5) { // Increment the thread a count. thread_a_count++; // Send out a message to the diagnostic port. - diag_printf( "INFO:<Thread A, count: %d message: %d>\n", thread_a_count, msg ); + diag_printf("INFO:<Thread A, count: %d message: %d>\n", thread_a_count, msg); // Delay for 1 second. - cyg_thread_delay( 100 ); + cyg_thread_delay(100); // Signal thread B using the semaphore. - cyg_semaphore_post( &sem_signal_thread ); + cyg_semaphore_post(&sem_signal_thread); } - CYG_TEST_CHECK( weak_fn_called == 2 , "Application week function not called" ); - CYG_TEST_FINISH( "Object loader test finished" ); + CYG_TEST_CHECK(weak_fn_called == 2 , "Application week function not called"); + CYG_TEST_FINISH("Object loader test finished"); } // Thread B - waits for semaphore signal from thread A. -void thread_b( cyg_addrword_t data ) +void thread_b(cyg_addrword_t data) { // Store the data value passed in for this thread. int msg = (int)data; - while( 1 ) + while(1) { // Signal thread B using the semaphore. - cyg_semaphore_wait( &sem_signal_thread ); + cyg_semaphore_wait(&sem_signal_thread); // Send out a message to the diagnostic port. - diag_printf( "INFO:< Thread B, message: %d>\n", msg ); + diag_printf("INFO:< Thread B, message: %d>\n", msg); } }
--- a/packages/services/objloader/current/tests/test_mods.c +++ b/packages/services/objloader/current/tests/test_mods.c @@ -42,7 +42,7 @@ * ================================================================= * #####DESCRIPTIONBEGIN#### * - * Author(s): atonizzo@lycos.com + * Author(s): Anthony Tonizzo (atonizzo@gmail.com) * Date: 2005-05-13 * Purpose: * Description: @@ -82,11 +82,11 @@ //========================================================================== -MTAB_ENTRY( romfs_mte1, +MTAB_ENTRY(romfs_mte1, "/", "romfs", "", - (CYG_ADDRWORD) &filedata[0] ); + (CYG_ADDRWORD) &filedata[0]); //========================================================================== @@ -102,78 +102,78 @@ cyg_thread thread_b_obj; cyg_handle_t thread_a_hdl; cyg_handle_t thread_b_hdl; -#define SHOW_RESULT( _fn, _res ) \ +#define SHOW_RESULT(_fn, _res) \ diag_printf("<FAIL>: " #_fn "() returned %d %s\n", _res, _res<0?strerror(errno):""); int weak_fn_called = 0; -void weak_function( void ) +void weak_function(void) { - CYG_TEST_PASS( "Applications weak function called" ); + CYG_TEST_PASS("Applications weak function called"); weak_fn_called++; } -void (*thread_a)( cyg_addrword_t ); -void (*thread_b)( cyg_addrword_t ); +void (*thread_a)(cyg_addrword_t); +void (*thread_b)(cyg_addrword_t); // This is the main starting point for our example application. -void cyg_user_start( void ) +void cyg_user_start(void) { int err; void* lib_handle; - void (*fn)( void ); + void (*fn)(void); CYG_TEST_INIT(); - CYG_TEST_INFO( "Object loader module test started" ); + CYG_TEST_INFO("Object loader module test started"); - err = chdir( "/" ); + err = chdir("/"); - if( err < 0 ) - SHOW_RESULT( chdir, err ); + if(err < 0) + SHOW_RESULT(chdir, err); - lib_handle = cyg_ldr_open_library( (CYG_ADDRWORD)"/hello.o", 0 ); - CYG_TEST_CHECK( lib_handle , "Unable to load object file to load" ); + lib_handle = cyg_ldr_open_library((CYG_ADDRWORD)"/hello.o", 0); + CYG_TEST_CHECK(lib_handle , "Unable to load object file to load"); - fn = cyg_ldr_find_symbol( lib_handle, "print_message" ); - CYG_TEST_CHECK( fn , "Unable to find print_message function" ); + fn = cyg_ldr_find_symbol(lib_handle, "print_message"); + CYG_TEST_CHECK(fn , "Unable to find print_message function"); fn(); - fn = cyg_ldr_find_symbol( lib_handle, "weak_function" ); - CYG_TEST_CHECK( fn , "Unable to find weak_function" ); + fn = cyg_ldr_find_symbol(lib_handle, "weak_function"); + CYG_TEST_CHECK(fn , "Unable to find weak_function"); fn(); - fn = cyg_ldr_find_symbol ( lib_handle, "unresolvable_symbol" ); - CYG_TEST_CHECK( !fn , "Found none existing symbol!" ); + fn = cyg_ldr_find_symbol (lib_handle, "unresolvable_symbol"); + CYG_TEST_CHECK(!fn , "Found none existing symbol!"); - thread_a = cyg_ldr_find_symbol( lib_handle, "thread_a" ); - thread_b = cyg_ldr_find_symbol( lib_handle, "thread_b" ); - CYG_TEST_CHECK( thread_a && thread_b , "Unable to find thread functions" ); + thread_a = cyg_ldr_find_symbol(lib_handle, "thread_a"); + thread_b = cyg_ldr_find_symbol(lib_handle, "thread_b"); + CYG_TEST_CHECK(thread_a && thread_b , "Unable to find thread functions"); // Create our two threads. - cyg_thread_create( THREAD_PRIORITY, + cyg_thread_create(THREAD_PRIORITY, thread_a, (cyg_addrword_t) 75, "Thread A", (void *)thread_a_stack, THREAD_STACK_SIZE, &thread_a_hdl, - &thread_a_obj ); + &thread_a_obj); - cyg_thread_create( THREAD_PRIORITY + 1, + cyg_thread_create(THREAD_PRIORITY + 1, thread_b, (cyg_addrword_t) 68, "Thread B", (void *)thread_b_stack, THREAD_STACK_SIZE, &thread_b_hdl, - &thread_b_obj ); + &thread_b_obj); // Resume the threads so they start when the scheduler begins. - cyg_thread_resume( thread_a_hdl ); - cyg_thread_resume( thread_b_hdl ); + cyg_thread_resume(thread_a_hdl); + cyg_thread_resume(thread_b_hdl); cyg_scheduler_start(); } @@ -200,11 +200,11 @@ CYG_LDR_TABLE_STDIO() CYG_LDR_TABLE_INFRA_DIAG() // Test case infrastructure function -CYG_LDR_TABLE_ENTRY( cyg_test_output_entry, "cyg_test_output", cyg_test_output ); -CYG_LDR_TABLE_ENTRY( cyg_test_exit_entry, "cyg_test_exit", cyg_test_exit ); +CYG_LDR_TABLE_ENTRY(cyg_test_output_entry, "cyg_test_output", cyg_test_output); +CYG_LDR_TABLE_ENTRY(cyg_test_exit_entry, "cyg_test_exit", cyg_test_exit); // Test function -CYG_LDR_TABLE_ENTRY( weak_function_entry, "weak_function", weak_function ); +CYG_LDR_TABLE_ENTRY(weak_function_entry, "weak_function", weak_function); // Test Variable -CYG_LDR_TABLE_ENTRY( weak_fn_called_entry, "weak_fn_called", &weak_fn_called ); +CYG_LDR_TABLE_ENTRY(weak_fn_called_entry, "weak_fn_called", &weak_fn_called);