From 957dca2082b4657021352c940d0486778b54ab7b Mon Sep 17 00:00:00 2001 From: Rajkumar Kanagaraj Date: Tue, 8 Oct 2019 08:04:02 -0700 Subject: [PATCH 1/4] Enabling small C library option and deprecating uARM toolchain MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - By default, Mbed OS build tools use standard C library for all supported toolchains. It is possible to use smaller C libraries by overriding the "target.default_lib" option with "small". This option is only currently supported for the GCC_ARM toolchain. This override config option is now extended in the build tool for ARM toolchain. - Add configuration option to specify libraries supported for each toolchain per targets. - Move __aeabi_assert function from rtos to retarget code so it’s available for bare metal. - Use 2 memory region model for ARM toolchain scatter file for the following targets: NUCLEO_F207ZG, STM32F411xE, STM32F429xI, NUCLEO_L073RZ, STM32F303xE - Add a warning message in the build tools to deprecate uARM toolchain. - NewLib-Nano C library is not supporting floating-point and printf with %hhd,%hhu,%hhX,%lld,%llu,%llX format specifier so skipping those green tea test cases. --- TESTS/configs/baremetal.json | 1 + TESTS/mbed_drivers/c_strings/main.cpp | 4 + .../minimal-printf/compliance/main.cpp | 40 +++++- platform/source/mbed_retarget.cpp | 8 ++ .../TOOLCHAIN_ARM_MICRO/mbed_boot_arm_micro.c | 5 - .../TOOLCHAIN_ARM_STD/mbed_boot_arm_std.c | 52 ++++++- .../device/TOOLCHAIN_ARM_STD/stm32f207xx.sct | 28 +++- .../device/TOOLCHAIN_ARM_STD/stm32f303xe.sct | 29 +++- .../device/TOOLCHAIN_ARM_STD/stm32f411re.sct | 45 +++--- .../device/TOOLCHAIN_ARM_STD/stm32f429xx.sct | 44 +++--- .../device/TOOLCHAIN_ARM_STD/stm32l073xz.sct | 40 ++++-- targets/targets.json | 55 +++++++- tools/build_api.py | 3 + ...ludes_d41d8cd98f00b204e9800998ecf8427e.txt | 0 ...acros_d41d8cd98f00b204e9800998ecf8427e.xcl | 0 tools/test/toolchains/test_toolchains.py | 131 +++++++++++++++++- tools/toolchains/arm.py | 16 ++- tools/toolchains/gcc.py | 6 +- tools/toolchains/iar.py | 3 +- tools/toolchains/mbed_toolchain.py | 19 +++ 20 files changed, 438 insertions(+), 91 deletions(-) create mode 100644 tools/test/toolchains/.includes_d41d8cd98f00b204e9800998ecf8427e.txt create mode 100644 tools/test/toolchains/asm_macros_d41d8cd98f00b204e9800998ecf8427e.xcl diff --git a/TESTS/configs/baremetal.json b/TESTS/configs/baremetal.json index bec2fd801b4..6bbfb1edf07 100644 --- a/TESTS/configs/baremetal.json +++ b/TESTS/configs/baremetal.json @@ -36,6 +36,7 @@ ], "target_overrides": { "*": { + "target.default_lib": "small", "mbed-trace.fea-ipv6": false } } diff --git a/TESTS/mbed_drivers/c_strings/main.cpp b/TESTS/mbed_drivers/c_strings/main.cpp index f592851769a..d0a6666965a 100644 --- a/TESTS/mbed_drivers/c_strings/main.cpp +++ b/TESTS/mbed_drivers/c_strings/main.cpp @@ -54,6 +54,7 @@ void test_case_c_string_x_X() TEST_ASSERT_EQUAL_STRING("8000 C8E 3e7 64 1 0 1 1087 3e7 101B 7ff8 1869F", buffer); } +#if !defined(__NEWLIB_NANO) void test_case_c_string_f_f() { CLEAN_BUFFER; @@ -74,6 +75,7 @@ void test_case_c_string_e_E() sprintf(buffer, "%e %E %e %E %e %E %e %E %e %E %e", FLOATS); TEST_ASSERT_EQUAL_STRING("2.000000e-03 9.243000E-01 1.591320e+01 7.917737E+02 6.208200e+03 2.571950E+04 4.268160e+05 6.429271E+06 4.246802e+07 2.120065E+08 6.579048e+03", buffer); } +#endif void test_case_c_string_strtok() { @@ -113,11 +115,13 @@ Case cases[] = { Case("C strings: %i %d integer formatting", test_case_c_string_i_d, greentea_failure_handler), Case("C strings: %u %d integer formatting", test_case_c_string_u_d, greentea_failure_handler), Case("C strings: %x %E integer formatting", test_case_c_string_x_X, greentea_failure_handler), +#if !defined(__NEWLIB_NANO) Case("C strings: %f %f float formatting", test_case_c_string_f_f, greentea_failure_handler), #ifndef MBED_MINIMAL_PRINTF Case("C strings: %e %E float formatting", test_case_c_string_e_E, greentea_failure_handler), Case("C strings: %g %g float formatting", test_case_c_string_g_g, greentea_failure_handler), #endif +#endif }; utest::v1::status_t greentea_test_setup(const size_t number_of_cases) diff --git a/TESTS/mbed_platform/minimal-printf/compliance/main.cpp b/TESTS/mbed_platform/minimal-printf/compliance/main.cpp index a1c9858ab75..e996d71aee1 100644 --- a/TESTS/mbed_platform/minimal-printf/compliance/main.cpp +++ b/TESTS/mbed_platform/minimal-printf/compliance/main.cpp @@ -51,6 +51,7 @@ static control_t test_printf_d(const size_t call_count) /*************************************************************************/ /*************************************************************************/ +#if !defined(__NEWLIB_NANO) result_minimal = mbed_printf("hhd: %hhd\r\n", SCHAR_MIN); result_file = mbed_fprintf(stderr, "hhd: %hhd\r\n", SCHAR_MIN); result_baseline = printf("hhd: %hhd\r\n", SCHAR_MIN); @@ -62,6 +63,7 @@ static control_t test_printf_d(const size_t call_count) result_baseline = printf("hhd: %hhd\r\n", SCHAR_MAX); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); +#endif result_minimal = mbed_printf("hd: %hd\r\n", SHRT_MIN); result_file = mbed_fprintf(stderr, "hd: %hd\r\n", SHRT_MIN); @@ -99,6 +101,7 @@ static control_t test_printf_d(const size_t call_count) TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); +#if !defined(__NEWLIB_NANO) result_minimal = mbed_printf("lld: %lld\r\n", LLONG_MIN); result_file = mbed_fprintf(stderr, "lld: %lld\r\n", LLONG_MIN); result_baseline = printf("lld: %lld\r\n", LLONG_MIN); @@ -110,6 +113,7 @@ static control_t test_printf_d(const size_t call_count) result_baseline = printf("lld: %lld\r\n", LLONG_MAX); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); +#endif #ifdef TARGET_LIKE_MBED printf("%%jd not supported by mbed\r\n"); @@ -170,6 +174,7 @@ static control_t test_printf_u(const size_t call_count) /*************************************************************************/ /*************************************************************************/ +#if !defined(__NEWLIB_NANO) result_minimal = mbed_printf("hhu: %hhu\r\n", 0); result_file = mbed_fprintf(stderr, "hhu: %hhu\r\n", 0); result_baseline = printf("hhu: %hhu\r\n", 0); @@ -181,6 +186,7 @@ static control_t test_printf_u(const size_t call_count) result_baseline = printf("hhu: %hhu\r\n", UCHAR_MAX); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); +#endif result_minimal = mbed_printf("hu: %hu\r\n", 0); result_file = mbed_fprintf(stderr, "hu: %hu\r\n", 0); @@ -217,7 +223,7 @@ static control_t test_printf_u(const size_t call_count) result_baseline = printf("lu: %lu\r\n", ULONG_MAX); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); - +#if !defined(__NEWLIB_NANO) result_minimal = mbed_printf("llu: %llu\r\n", 0ULL); result_file = mbed_fprintf(stderr, "llu: %llu\r\n", 0ULL); result_baseline = printf("llu: %llu\r\n", 0ULL); @@ -229,6 +235,7 @@ static control_t test_printf_u(const size_t call_count) result_baseline = printf("llu: %llu\r\n", ULLONG_MAX); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); +#endif #ifdef TARGET_LIKE_MBED printf("%%ju not supported by mbed\r\n"); @@ -289,6 +296,7 @@ static control_t test_printf_x(const size_t call_count) /*************************************************************************/ /*************************************************************************/ +#if !defined(__NEWLIB_NANO) result_minimal = mbed_printf("hhX: %hhX\r\n", 0); result_file = mbed_fprintf(stderr, "hhX: %hhX\r\n", 0); result_baseline = printf("hhX: %hhX\r\n", 0); @@ -300,6 +308,7 @@ static control_t test_printf_x(const size_t call_count) result_baseline = printf("hhX: %hhX\r\n", UCHAR_MAX); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); +#endif result_minimal = mbed_printf("hX: %hX\r\n", 0); result_file = mbed_fprintf(stderr, "hX: %hX\r\n", 0); @@ -336,7 +345,7 @@ static control_t test_printf_x(const size_t call_count) result_baseline = printf("lX: %lX\r\n", ULONG_MAX); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); - +#if !defined(__NEWLIB_NANO) result_minimal = mbed_printf("llX: %llX\r\n", 0ULL); result_file = mbed_fprintf(stderr, "llX: %llX\r\n", 0ULL); result_baseline = printf("llX: %llX\r\n", 0ULL); @@ -348,6 +357,7 @@ static control_t test_printf_x(const size_t call_count) result_baseline = printf("llX: %llX\r\n", ULLONG_MAX); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); +#endif #ifdef TARGET_LIKE_MBED printf("%%jX not supported by mbed\r\n"); @@ -434,6 +444,7 @@ static control_t test_snprintf_d(const size_t call_count) /*************************************************************************/ /*************************************************************************/ +#if !defined(__NEWLIB_NANO) result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hhd: %hhd\r\n", SCHAR_MIN); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hhd: %hhd\r\n", SCHAR_MIN); TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); @@ -443,6 +454,7 @@ static control_t test_snprintf_d(const size_t call_count) result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hhd: %hhd\r\n", SCHAR_MAX); TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); +#endif result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hd: %hd\r\n", SHRT_MIN); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hd: %hd\r\n", SHRT_MIN); @@ -474,6 +486,7 @@ static control_t test_snprintf_d(const size_t call_count) TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); +#if !defined(__NEWLIB_NANO) result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "lld: %lld\r\n", LLONG_MIN); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "lld: %lld\r\n", LLONG_MIN); TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); @@ -483,6 +496,7 @@ static control_t test_snprintf_d(const size_t call_count) result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "lld: %lld\r\n", LLONG_MAX); TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); +#endif #ifdef TARGET_LIKE_MBED printf("%%jd not supported by mbed\r\n"); @@ -538,6 +552,7 @@ static control_t test_snprintf_u(const size_t call_count) /*************************************************************************/ /*************************************************************************/ +#if !defined(__NEWLIB_NANO) result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hhu: %hhu\r\n", 0); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hhu: %hhu\r\n", 0); TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); @@ -547,6 +562,7 @@ static control_t test_snprintf_u(const size_t call_count) result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hhu: %hhu\r\n", UCHAR_MAX); TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); +#endif result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hu: %hu\r\n", 0); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hu: %hu\r\n", 0); @@ -577,7 +593,7 @@ static control_t test_snprintf_u(const size_t call_count) result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "lu: %lu\r\n", ULONG_MAX); TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); - +#if !defined(__NEWLIB_NANO) result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "llu: %llu\r\n", 0ULL); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "llu: %llu\r\n", 0ULL); TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); @@ -587,6 +603,7 @@ static control_t test_snprintf_u(const size_t call_count) result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "llu: %llu\r\n", ULLONG_MAX); TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); +#endif #ifdef TARGET_LIKE_MBED printf("%%ju not supported by mbed\r\n"); @@ -642,6 +659,7 @@ static control_t test_snprintf_x(const size_t call_count) /*************************************************************************/ /*************************************************************************/ +#if !defined(__NEWLIB_NANO) result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hhX: %hhX\r\n", 0); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hhX: %hhX\r\n", 0); TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); @@ -651,6 +669,7 @@ static control_t test_snprintf_x(const size_t call_count) result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hhX: %hhX\r\n", UCHAR_MAX); TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); +#endif result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hX: %hX\r\n", 0); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hX: %hX\r\n", 0); @@ -680,7 +699,7 @@ static control_t test_snprintf_x(const size_t call_count) result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "lX: %lX\r\n", ULONG_MAX); TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); - +#if !defined(__NEWLIB_NANO) result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "llX: %llX\r\n", 0ULL); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "llX: %llX\r\n", 0ULL); TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); @@ -690,6 +709,7 @@ static control_t test_snprintf_x(const size_t call_count) result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "llX: %llX\r\n", ULLONG_MAX); TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); +#endif #ifdef TARGET_LIKE_MBED printf("%%jX not supported by mbed\r\n"); @@ -902,10 +922,12 @@ static control_t test_snprintf_buffer_overflow_ld(const size_t call_count) return test_snprintf_buffer_overflow_generic("ld: %ld", -1048576L); } +#if !defined(__NEWLIB_NANO) static control_t test_snprintf_buffer_overflow_lld(const size_t call_count) { return test_snprintf_buffer_overflow_generic("lld: %lld", -1099511627776LL); } +#endif static control_t test_snprintf_buffer_overflow_u(const size_t call_count) { @@ -917,10 +939,12 @@ static control_t test_snprintf_buffer_overflow_lu(const size_t call_count) return test_snprintf_buffer_overflow_generic("lu: %lu", 1048576UL); } +#if !defined(__NEWLIB_NANO) static control_t test_snprintf_buffer_overflow_llu(const size_t call_count) { return test_snprintf_buffer_overflow_generic("llu: %llu", 1099511627776ULL); } +#endif static control_t test_snprintf_buffer_overflow_x(const size_t call_count) { @@ -932,10 +956,12 @@ static control_t test_snprintf_buffer_overflow_lx(const size_t call_count) return test_snprintf_buffer_overflow_generic("lx: 0x%lx", 0x100000UL); } +#if !defined(__NEWLIB_NANO) static control_t test_snprintf_buffer_overflow_llx(const size_t call_count) { return test_snprintf_buffer_overflow_generic("llx: 0x%llx", 0x10000000000ULL); } +#endif utest::v1::status_t greentea_setup(const size_t number_of_cases) { @@ -959,13 +985,15 @@ Case cases[] = { #endif Case("snprintf buffer overflow %d", test_snprintf_buffer_overflow_d), Case("snprintf buffer overflow %ld", test_snprintf_buffer_overflow_ld), - Case("snprintf buffer overflow %lld", test_snprintf_buffer_overflow_lld), Case("snprintf buffer overflow %u", test_snprintf_buffer_overflow_u), Case("snprintf buffer overflow %lu", test_snprintf_buffer_overflow_lu), - Case("snprintf buffer overflow %llu", test_snprintf_buffer_overflow_llu), Case("snprintf buffer overflow %x", test_snprintf_buffer_overflow_x), Case("snprintf buffer overflow %lx", test_snprintf_buffer_overflow_lx), +#if !defined(__NEWLIB_NANO) + Case("snprintf buffer overflow %lld", test_snprintf_buffer_overflow_lld), + Case("snprintf buffer overflow %llu", test_snprintf_buffer_overflow_llu), Case("snprintf buffer overflow %llx", test_snprintf_buffer_overflow_llx), +#endif }; Specification specification(greentea_setup, cases, greentea_test_teardown_handler); diff --git a/platform/source/mbed_retarget.cpp b/platform/source/mbed_retarget.cpp index a31cadbc0c5..cee0c57436e 100644 --- a/platform/source/mbed_retarget.cpp +++ b/platform/source/mbed_retarget.cpp @@ -1572,6 +1572,14 @@ extern "C" { } // end of extern "C" +#if defined(__MICROLIB) +extern "C" { + MBED_WEAK void __aeabi_assert(const char *expr, const char *file, int line) + { + mbed_assert_internal(expr, file, line); + } +} // end of extern "C" +#endif #endif diff --git a/rtos/source/TARGET_CORTEX/TOOLCHAIN_ARM_MICRO/mbed_boot_arm_micro.c b/rtos/source/TARGET_CORTEX/TOOLCHAIN_ARM_MICRO/mbed_boot_arm_micro.c index c2ce8ddb198..f2f86f613fc 100644 --- a/rtos/source/TARGET_CORTEX/TOOLCHAIN_ARM_MICRO/mbed_boot_arm_micro.c +++ b/rtos/source/TARGET_CORTEX/TOOLCHAIN_ARM_MICRO/mbed_boot_arm_micro.c @@ -63,8 +63,3 @@ void mbed_toolchain_init() /* Run the C++ global object constructors */ $Super$$__cpp_initialize__aeabi_(); } - -MBED_WEAK void __aeabi_assert(const char *expr, const char *file, int line) -{ - mbed_assert_internal(expr, file, line); -} diff --git a/rtos/source/TARGET_CORTEX/TOOLCHAIN_ARM_STD/mbed_boot_arm_std.c b/rtos/source/TARGET_CORTEX/TOOLCHAIN_ARM_STD/mbed_boot_arm_std.c index 412058517d5..d7b909b6a26 100644 --- a/rtos/source/TARGET_CORTEX/TOOLCHAIN_ARM_STD/mbed_boot_arm_std.c +++ b/rtos/source/TARGET_CORTEX/TOOLCHAIN_ARM_STD/mbed_boot_arm_std.c @@ -16,10 +16,14 @@ */ #include #include +#include "mbed_boot.h" + +extern uint32_t Image$$ARM_LIB_STACK$$ZI$$Base[]; +extern uint32_t Image$$ARM_LIB_STACK$$ZI$$Length[]; +#if !defined(__MICROLIB) #include "cmsis.h" #include "mbed_critical.h" -#include "mbed_boot.h" #include #include "mbed_rtos_storage.h" #include "cmsis_os2.h" @@ -27,8 +31,6 @@ __value_in_regs struct __argc_argv __rt_lib_init(unsigned heapbase, unsigned heaptop); void _platform_post_stackheap_init(void); -extern uint32_t Image$$ARM_LIB_STACK$$ZI$$Base[]; -extern uint32_t Image$$ARM_LIB_STACK$$ZI$$Length[]; #if !defined(HEAP_START) // Heap here is considered starting after ZI ends to Stack start @@ -252,3 +254,47 @@ __USED void _mutex_free(mutex *m) } #endif /* RTX_NO_MULTITHREAD_CLIB */ +#else +#include + +extern uint32_t Image$$ARM_LIB_HEAP$$ZI$$Base[]; +extern uint32_t Image$$ARM_LIB_HEAP$$ZI$$Length[]; + +/* + * mbed entry point for the MICROLIB toolchain + * + * Override the microlib function _main_init to run code earlier in + * the boot sequence. The function _main_init is responsible for invoking main. + * This function must be placed in the ".ARM.Collect" section + * or it won't get called. + */ +void _main_init(void) __attribute__((section(".ARM.Collect$$$$000000FF"))); +void _main_init(void) +{ + /* microlib only supports the two region memory model */ + mbed_stack_isr_start = (unsigned char *) Image$$ARM_LIB_STACK$$ZI$$Base; + mbed_stack_isr_size = (uint32_t) Image$$ARM_LIB_STACK$$ZI$$Length; + + mbed_heap_start = (unsigned char *) Image$$ARM_LIB_HEAP$$ZI$$Base; + mbed_heap_size = (uint32_t) Image$$ARM_LIB_HEAP$$ZI$$Length; + + mbed_init(); + mbed_rtos_start(); +} + +void $Sub$$__cpp_initialize__aeabi_(void); +void $Super$$__cpp_initialize__aeabi_(void); +void $Sub$$__cpp_initialize__aeabi_(void) +{ + /* This should invoke C++ initializers but we keep + * this empty and invoke them RTX is initialized. + */ +} + +void mbed_toolchain_init() +{ + /* Run the C++ global object constructors */ + $Super$$__cpp_initialize__aeabi_(); +} + +#endif // !defined(__MICROLIB) diff --git a/targets/TARGET_STM/TARGET_STM32F2/TARGET_NUCLEO_F207ZG/device/TOOLCHAIN_ARM_STD/stm32f207xx.sct b/targets/TARGET_STM/TARGET_STM32F2/TARGET_NUCLEO_F207ZG/device/TOOLCHAIN_ARM_STD/stm32f207xx.sct index cae669bfdf1..edde48e49ef 100644 --- a/targets/TARGET_STM/TARGET_STM32F2/TARGET_NUCLEO_F207ZG/device/TOOLCHAIN_ARM_STD/stm32f207xx.sct +++ b/targets/TARGET_STM/TARGET_STM32F2/TARGET_NUCLEO_F207ZG/device/TOOLCHAIN_ARM_STD/stm32f207xx.sct @@ -36,25 +36,39 @@ #define MBED_APP_SIZE 0x100000 #endif +#if !defined(MBED_RAM_START) + #define MBED_RAM_START 0x20000000 +#endif + +#if !defined(MBED_RAM_SIZE) + #define MBED_RAM_SIZE 0x00020000 +#endif + + #if !defined(MBED_BOOT_STACK_SIZE) #define MBED_BOOT_STACK_SIZE 0x400 #endif -#define Stack_Size MBED_BOOT_STACK_SIZE +; 97 vectors * 4 bytes = 388 bytes to reserve (0x184) 8-byte aligned = 0x188 (0x184 + 0x4) +#define VECTOR_SIZE 0x188 -LR_IROM1 MBED_APP_START MBED_APP_SIZE { ; load region size_region - ER_IROM1 MBED_APP_START MBED_APP_SIZE { ; load address = execution address +#define RAM_FIXED_SIZE (MBED_BOOT_STACK_SIZE+VECTOR_SIZE) + +LR_IROM1 MBED_APP_START MBED_APP_SIZE { ; load region size_region + + ER_IROM1 MBED_APP_START MBED_APP_SIZE { ; load address = execution address *.o (RESET, +First) *(InRoot$$Sections) .ANY (+RO) } - ; 97 vectors * 4 bytes = 388 bytes to reserve (0x184) 8-byte aligned = 0x188 (0x184 + 0x4) - RW_IRAM1 (0x20000000+0x188) (0x00020000-0x188-Stack_Size) { ; RW data + RW_IRAM1 (MBED_RAM_START+VECTOR_SIZE) (MBED_RAM_SIZE-VECTOR_SIZE) { ; RW data .ANY (+RW +ZI) } - ARM_LIB_STACK (0x20000000+0x00020000) EMPTY -Stack_Size { ; stack + ARM_LIB_HEAP AlignExpr(+0, 16) EMPTY (MBED_RAM_SIZE-RAM_FIXED_SIZE+MBED_RAM_START-AlignExpr(ImageLimit(RW_IRAM1), 16)) { } -} + ARM_LIB_STACK (MBED_RAM_START+MBED_RAM_SIZE) EMPTY -MBED_BOOT_STACK_SIZE { ; stack + } +} diff --git a/targets/TARGET_STM/TARGET_STM32F3/TARGET_STM32F303xE/device/TOOLCHAIN_ARM_STD/stm32f303xe.sct b/targets/TARGET_STM/TARGET_STM32F3/TARGET_STM32F303xE/device/TOOLCHAIN_ARM_STD/stm32f303xe.sct index 02373d988fc..161fecdee79 100644 --- a/targets/TARGET_STM/TARGET_STM32F3/TARGET_STM32F303xE/device/TOOLCHAIN_ARM_STD/stm32f303xe.sct +++ b/targets/TARGET_STM/TARGET_STM32F3/TARGET_STM32F303xE/device/TOOLCHAIN_ARM_STD/stm32f303xe.sct @@ -32,31 +32,46 @@ #define MBED_APP_START 0x08000000 #endif +; STM32F303RE: 512KB FLASH (0x80000) #if !defined(MBED_APP_SIZE) #define MBED_APP_SIZE 0x80000 #endif +;64KB SRAM (0x10000) +#if !defined(MBED_RAM_START) + #define MBED_RAM_START 0x20000000 +#endif + +#if !defined(MBED_RAM_SIZE) + #define MBED_RAM_SIZE 0x10000 +#endif + + #if !defined(MBED_BOOT_STACK_SIZE) #define MBED_BOOT_STACK_SIZE 0x400 #endif -#define Stack_Size MBED_BOOT_STACK_SIZE +; 101 vectors = 404 bytes (0x194) 8-byte aligned = 0x198 (0x194 + 0x4) to be reserved in RAM +#define VECTOR_SIZE 0x198 + +#define RAM_FIXED_SIZE (MBED_BOOT_STACK_SIZE+VECTOR_SIZE) -; STM32F303RE: 512KB FLASH (0x80000) + 64KB SRAM (0x10000) + 16KB CCMRAM (0x4000) -LR_IROM1 MBED_APP_START MBED_APP_SIZE { ; load region size_region +LR_IROM1 MBED_APP_START MBED_APP_SIZE { ; load region size_region - ER_IROM1 MBED_APP_START MBED_APP_SIZE { ; load address = execution address + ER_IROM1 MBED_APP_START MBED_APP_SIZE { ; load address = execution address *.o (RESET, +First) *(InRoot$$Sections) .ANY (+RO) } - ; 101 vectors = 404 bytes (0x194) 8-byte aligned = 0x198 (0x194 + 0x4) to be reserved in RAM - RW_IRAM1 (0x20000000+0x198) (0x10000-0x198-Stack_Size) { ; RW data + RW_IRAM1 (MBED_RAM_START+VECTOR_SIZE) (MBED_RAM_SIZE-VECTOR_SIZE) { ; RW data .ANY (+RW +ZI) } - ARM_LIB_STACK (0x20000000+0x10000) EMPTY -Stack_Size { ; stack + ARM_LIB_HEAP AlignExpr(+0, 16) EMPTY (MBED_RAM_SIZE-RAM_FIXED_SIZE+MBED_RAM_START-AlignExpr(ImageLimit(RW_IRAM1), 16)) { + } + + ARM_LIB_STACK (MBED_RAM_START+MBED_RAM_SIZE) EMPTY -MBED_BOOT_STACK_SIZE { ; stack } CCMRAM (0x10000000) (0x4000) { diff --git a/targets/TARGET_STM/TARGET_STM32F4/TARGET_STM32F411xE/device/TOOLCHAIN_ARM_STD/stm32f411re.sct b/targets/TARGET_STM/TARGET_STM32F4/TARGET_STM32F411xE/device/TOOLCHAIN_ARM_STD/stm32f411re.sct index 6bfeeaeae2d..f6d63fffdc4 100644 --- a/targets/TARGET_STM/TARGET_STM32F4/TARGET_STM32F411xE/device/TOOLCHAIN_ARM_STD/stm32f411re.sct +++ b/targets/TARGET_STM/TARGET_STM32F4/TARGET_STM32F411xE/device/TOOLCHAIN_ARM_STD/stm32f411re.sct @@ -32,43 +32,54 @@ #define MBED_APP_START 0x08000000 #endif +; STM32F411RE: 512 KB FLASH (0x80000) #if !defined(MBED_APP_SIZE) #define MBED_APP_SIZE 0x80000 #endif +; 128 KB SRAM (0x20000) +#if !defined(MBED_RAM_START) + #define MBED_RAM_START 0x20000000 +#endif + +#if !defined(MBED_RAM_SIZE) + #define MBED_RAM_SIZE 0x20000 +#endif + + #if !defined(MBED_BOOT_STACK_SIZE) #define MBED_BOOT_STACK_SIZE 0x400 #endif -#define Stack_Size MBED_BOOT_STACK_SIZE +; Total: 102 vectors = 408 bytes (0x198) to be reserved in RAM +#define VECTOR_SIZE 0x198 -#define MBED_RAM_START 0x20000000 -#define MBED_RAM_SIZE 0x20000 -#define MBED_VECTTABLE_RAM_START (MBED_RAM_START) -#define MBED_VECTTABLE_RAM_SIZE 0x198 -#define MBED_CRASH_REPORT_RAM_START (MBED_VECTTABLE_RAM_START + MBED_VECTTABLE_RAM_SIZE) #define MBED_CRASH_REPORT_RAM_SIZE 0x100 -#define MBED_RAM0_START (MBED_CRASH_REPORT_RAM_START + MBED_CRASH_REPORT_RAM_SIZE) -#define MBED_RAM0_SIZE (MBED_RAM_SIZE - MBED_VECTTABLE_RAM_SIZE - MBED_CRASH_REPORT_RAM_SIZE) -; STM32F411RE: 512 KB FLASH (0x80000) + 128 KB SRAM (0x20000) -LR_IROM1 MBED_APP_START MBED_APP_SIZE { ; load region size_region +#define MBED_IRAM1_START (MBED_RAM_START + VECTOR_SIZE + MBED_CRASH_REPORT_RAM_SIZE) +#define MBED_IRAM1_SIZE (MBED_RAM_SIZE - VECTOR_SIZE - MBED_CRASH_REPORT_RAM_SIZE) + - ER_IROM1 MBED_APP_START MBED_APP_SIZE { ; load address = execution address +#define RAM_FIXED_SIZE (MBED_BOOT_STACK_SIZE+VECTOR_SIZE+MBED_CRASH_REPORT_RAM_SIZE) + +LR_IROM1 MBED_APP_START MBED_APP_SIZE { ; load region size_region + + ER_IROM1 MBED_APP_START MBED_APP_SIZE { ; load address = execution address *.o (RESET, +First) *(InRoot$$Sections) .ANY (+RO) } - - RW_m_crash_data MBED_CRASH_REPORT_RAM_START EMPTY MBED_CRASH_REPORT_RAM_SIZE { ; RW data + + RW_m_crash_data (MBED_RAM_START+VECTOR_SIZE) EMPTY MBED_CRASH_REPORT_RAM_SIZE { ; RW data } - ; Total: 102 vectors = 408 bytes (0x198) to be reserved in RAM - RW_IRAM1 (MBED_RAM0_START) (MBED_RAM0_SIZE-Stack_Size) { ; RW data + RW_IRAM1 MBED_IRAM1_START MBED_IRAM1_SIZE { ; RW data .ANY (+RW +ZI) } - ARM_LIB_STACK (MBED_RAM0_START+MBED_RAM0_SIZE) EMPTY -Stack_Size { ; stack + ARM_LIB_HEAP AlignExpr(+0, 16) EMPTY (MBED_RAM_SIZE-RAM_FIXED_SIZE+MBED_RAM_START-AlignExpr(ImageLimit(RW_IRAM1), 16)) { } -} + ARM_LIB_STACK (MBED_RAM_START+MBED_RAM_SIZE) EMPTY -MBED_BOOT_STACK_SIZE { ; stack + } +} diff --git a/targets/TARGET_STM/TARGET_STM32F4/TARGET_STM32F429xI/device/TOOLCHAIN_ARM_STD/stm32f429xx.sct b/targets/TARGET_STM/TARGET_STM32F4/TARGET_STM32F429xI/device/TOOLCHAIN_ARM_STD/stm32f429xx.sct index 0bd8941a1dc..a8e27863aba 100644 --- a/targets/TARGET_STM/TARGET_STM32F4/TARGET_STM32F429xI/device/TOOLCHAIN_ARM_STD/stm32f429xx.sct +++ b/targets/TARGET_STM/TARGET_STM32F4/TARGET_STM32F429xI/device/TOOLCHAIN_ARM_STD/stm32f429xx.sct @@ -32,47 +32,51 @@ #define MBED_APP_START 0x08000000 #endif +; 2 MB FLASH (0x200000) #if !defined(MBED_APP_SIZE) #define MBED_APP_SIZE 0x200000 #endif +;256 KB SRAM (0x30000 + 0x10000) +#if !defined(MBED_RAM_START) + #define MBED_RAM_START 0x20000000 +#endif + +#if !defined(MBED_RAM_SIZE) + #define MBED_RAM_SIZE 0x30000 +#endif + + #if !defined(MBED_BOOT_STACK_SIZE) #define MBED_BOOT_STACK_SIZE 0x400 #endif -#define Stack_Size MBED_BOOT_STACK_SIZE +; Total: 107 vectors = 428 bytes (0x1AC) 8-byte aligned = 0x1B0 (0x1AC + 0x4) to be reserved in RAM +#define VECTOR_SIZE 0x1B0 -#define MBED_RAM_START 0x20000000 -#define MBED_RAM_SIZE 0x30000 -#define MBED_VECTTABLE_RAM_START (MBED_RAM_START) -#define MBED_VECTTABLE_RAM_SIZE 0x1B0 -#define MBED_CRASH_REPORT_RAM_START (MBED_VECTTABLE_RAM_START + MBED_VECTTABLE_RAM_SIZE) #define MBED_CRASH_REPORT_RAM_SIZE 0x100 -#define MBED_RAM0_START (MBED_CRASH_REPORT_RAM_START + MBED_CRASH_REPORT_RAM_SIZE) -#define MBED_RAM0_SIZE (MBED_RAM_SIZE - MBED_VECTTABLE_RAM_SIZE - MBED_CRASH_REPORT_RAM_SIZE) +#define MBED_IRAM1_START (MBED_RAM_START + VECTOR_SIZE + MBED_CRASH_REPORT_RAM_SIZE) +#define MBED_IRAM1_SIZE (MBED_RAM_SIZE - VECTOR_SIZE - MBED_CRASH_REPORT_RAM_SIZE) +#define RAM_FIXED_SIZE (MBED_BOOT_STACK_SIZE + VECTOR_SIZE + MBED_CRASH_REPORT_RAM_SIZE) -; 2 MB FLASH (0x200000) + 256 KB SRAM (0x30000 + 0x10000) -LR_IROM1 MBED_APP_START MBED_APP_SIZE { ; load region size_region +LR_IROM1 MBED_APP_START MBED_APP_SIZE { ; load region size_region - ER_IROM1 MBED_APP_START MBED_APP_SIZE { ; load address = execution address + ER_IROM1 MBED_APP_START MBED_APP_SIZE { ; load address = execution address *.o (RESET, +First) *(InRoot$$Sections) .ANY (+RO) } - - RW_m_crash_data MBED_CRASH_REPORT_RAM_START EMPTY MBED_CRASH_REPORT_RAM_SIZE { ; RW data + + RW_m_crash_data (MBED_RAM_START+VECTOR_SIZE) EMPTY MBED_CRASH_REPORT_RAM_SIZE { ; RW data } - ; Total: 107 vectors = 428 bytes (0x1AC) 8-byte aligned = 0x1B0 (0x1AC + 0x4) to be reserved in RAM - RW_IRAM1 (MBED_RAM0_START) (MBED_RAM0_SIZE-Stack_Size) { ; RW data + RW_IRAM1 MBED_IRAM1_START MBED_IRAM1_SIZE { ; RW data .ANY (+RW +ZI) } - - RW_IRAM2 (0x10000000) (0x10000) { ; RW data - .ANY (+RW +ZI) + + ARM_LIB_HEAP AlignExpr(+0, 16) EMPTY (MBED_RAM_SIZE-RAM_FIXED_SIZE+MBED_RAM_START-AlignExpr(ImageLimit(RW_IRAM1), 16)) { } - ARM_LIB_STACK (MBED_RAM0_START+MBED_RAM0_SIZE) EMPTY -Stack_Size { ; stack + ARM_LIB_STACK (MBED_RAM_START+MBED_RAM_SIZE) EMPTY -MBED_BOOT_STACK_SIZE { ; stack } } - diff --git a/targets/TARGET_STM/TARGET_STM32L0/TARGET_NUCLEO_L073RZ/device/TOOLCHAIN_ARM_STD/stm32l073xz.sct b/targets/TARGET_STM/TARGET_STM32L0/TARGET_NUCLEO_L073RZ/device/TOOLCHAIN_ARM_STD/stm32l073xz.sct index 0f149614488..5e77511cd39 100644 --- a/targets/TARGET_STM/TARGET_STM32L0/TARGET_NUCLEO_L073RZ/device/TOOLCHAIN_ARM_STD/stm32l073xz.sct +++ b/targets/TARGET_STM/TARGET_STM32L0/TARGET_NUCLEO_L073RZ/device/TOOLCHAIN_ARM_STD/stm32l073xz.sct @@ -28,35 +28,49 @@ ; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#if !defined(MBED_BOOT_STACK_SIZE) - #define MBED_BOOT_STACK_SIZE 0x400 -#endif - #if !defined(MBED_APP_START) #define MBED_APP_START 0x08000000 #endif - #if !defined(MBED_APP_SIZE) +; STM32L073RZ: 192KB FLASH (0x30000) +#if !defined(MBED_APP_SIZE) #define MBED_APP_SIZE 0x30000 #endif -#define Stack_Size MBED_BOOT_STACK_SIZE +; 20KB RAM (0x5000) +#if !defined(MBED_RAM_START) + #define MBED_RAM_START 0x20000000 +#endif + +#if !defined(MBED_RAM_SIZE) + #define MBED_RAM_SIZE 0x5000 +#endif -; STM32L073RZ: 192KB FLASH (0x30000) + 20KB RAM (0x5000) -LR_IROM1 MBED_APP_START MBED_APP_SIZE { ; load region size_region - ER_IROM1 MBED_APP_START MBED_APP_SIZE { ; load address = execution address +#if !defined(MBED_BOOT_STACK_SIZE) + #define MBED_BOOT_STACK_SIZE 0x400 +#endif + +; Total: 48 vectors = 192 bytes (0xC0) to be reserved in RAM +#define VECTOR_SIZE 0xC0 + +#define RAM_FIXED_SIZE (MBED_BOOT_STACK_SIZE+VECTOR_SIZE) + +LR_IROM1 MBED_APP_START MBED_APP_SIZE { ; load region size_region + + ER_IROM1 MBED_APP_START MBED_APP_SIZE { ; load address = execution address *.o (RESET, +First) *(InRoot$$Sections) .ANY (+RO) } - ; Total: 48 vectors = 192 bytes (0xC0) to be reserved in RAM - RW_IRAM1 (0x20000000+0xC0) (0x5000-0xC0-Stack_Size) { ; RW data + RW_IRAM1 (MBED_RAM_START+VECTOR_SIZE) (MBED_RAM_SIZE-VECTOR_SIZE) { ; RW data .ANY (+RW +ZI) } - ARM_LIB_STACK (0x20000000+0x5000) EMPTY -Stack_Size { ; stack + ARM_LIB_HEAP AlignExpr(+0, 16) EMPTY (MBED_RAM_SIZE-RAM_FIXED_SIZE+MBED_RAM_START-AlignExpr(ImageLimit(RW_IRAM1), 16)) { } -} + ARM_LIB_STACK (MBED_RAM_START+MBED_RAM_SIZE) EMPTY -MBED_BOOT_STACK_SIZE { ; stack + } +} diff --git a/targets/targets.json b/targets/targets.json index 9ee6bf0a4a8..a2029e467be 100644 --- a/targets/targets.json +++ b/targets/targets.json @@ -16,6 +16,11 @@ "bootloader_supported": false, "static_memory_defines": true, "printf_lib": "std", + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + }, "config": { "console-uart": { "help": "Target has UART console on pins STDIO_UART_TX, STDIO_UART_RX. Value is only significant if target has SERIAL device.", @@ -1503,6 +1508,11 @@ "bootloader_supported": true, "overrides": { "network-default-interface-type": "ETHERNET" + }, + "supported_c_libs": { + "arm": ["std", "small"], + "gcc_arm": ["std", "small"], + "iar": ["std"] } }, "SDT64B": { @@ -1790,6 +1800,11 @@ "bootloader_supported": true, "overrides": { "network-default-interface-type": "ETHERNET" + }, + "supported_c_libs": { + "arm": ["std", "small"], + "gcc_arm": ["std", "small"], + "iar": ["std"] } }, "K82F": { @@ -2121,7 +2136,12 @@ "init-us-ticker-at-boot": true }, "OUTPUT_EXT": "hex", - "bootloader_supported": true + "bootloader_supported": true, + "supported_c_libs": { + "arm": ["std", "small"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + } }, "LPC55S69_S": { "inherits": ["SPE_Target", "LPC55S69"], @@ -2441,7 +2461,12 @@ ], "release_versions": ["2", "5"], "bootloader_supported": true, - "device_name": "STM32F303RE" + "device_name": "STM32F303RE", + "supported_c_libs": { + "arm": ["std", "small"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + } }, "NUCLEO_F303ZE": { "inherits": ["FAMILY_STM32"], @@ -2579,7 +2604,12 @@ ], "release_versions": ["2", "5"], "device_name": "STM32F411RE", - "bootloader_supported": true + "bootloader_supported": true, + "supported_c_libs": { + "arm": ["std", "small"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + } }, "NUCLEO_F412ZG": { "inherits": ["FAMILY_STM32"], @@ -2831,6 +2861,11 @@ "bootloader_supported": true, "overrides": { "network-default-interface-type": "ETHERNET" + }, + "supported_c_libs": { + "arm": ["std", "small"], + "gcc_arm": ["std", "small"], + "iar": ["std"] } }, "MTB_STM_S2LP": { @@ -3534,7 +3569,12 @@ ], "release_versions": ["2", "5"], "bootloader_supported": true, - "device_name": "STM32L073RZ" + "device_name": "STM32L073RZ", + "supported_c_libs": { + "arm": ["std", "small"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + } }, "NUCLEO_L152RE": { "inherits": ["FAMILY_STM32"], @@ -4425,7 +4465,12 @@ ], "release_versions": ["2", "5"], "device_name": "STM32L475VG", - "bootloader_supported": true + "bootloader_supported": true, + "supported_c_libs": { + "arm": ["std", "small"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + } }, "MTB_STM_L475": { "inherits": ["FAMILY_STM32"], diff --git a/tools/build_api.py b/tools/build_api.py index 8aeb3537c64..8f877e224b7 100755 --- a/tools/build_api.py +++ b/tools/build_api.py @@ -47,6 +47,7 @@ from .libraries import Library from .toolchains import TOOLCHAIN_CLASSES, TOOLCHAIN_PATHS from .toolchains.arm import ARMC5_MIGRATION_WARNING +from .toolchains.arm import UARM_TOOLCHAIN_WARNING from .config import Config RELEASE_VERSIONS = ['2', '5'] @@ -242,6 +243,8 @@ def find_valid_toolchain(target, toolchain): "Currently set search path: {}" ).format(toolchain_name, search_path) else: + if toolchain_name == "uARM" or target.default_toolchain == "uARM": + end_warnings.append(UARM_TOOLCHAIN_WARNING) return toolchain_name, internal_tc_name, end_warnings else: if last_error: diff --git a/tools/test/toolchains/.includes_d41d8cd98f00b204e9800998ecf8427e.txt b/tools/test/toolchains/.includes_d41d8cd98f00b204e9800998ecf8427e.txt new file mode 100644 index 00000000000..e69de29bb2d diff --git a/tools/test/toolchains/asm_macros_d41d8cd98f00b204e9800998ecf8427e.xcl b/tools/test/toolchains/asm_macros_d41d8cd98f00b204e9800998ecf8427e.xcl new file mode 100644 index 00000000000..e69de29bb2d diff --git a/tools/test/toolchains/test_toolchains.py b/tools/test/toolchains/test_toolchains.py index 0a8dca2675e..500077dbad2 100644 --- a/tools/test/toolchains/test_toolchains.py +++ b/tools/test/toolchains/test_toolchains.py @@ -20,7 +20,8 @@ from tools.toolchains.arm import ARM_STD, ARM_MICRO, ARMC6 from tools.toolchains.gcc import GCC_ARM from tools.toolchains.iar import IAR - +from tools.toolchains.mbed_toolchain import UNSUPPORTED_C_LIB_EXECPTION_STRING +from tools.utils import NotSupportedException class TestArmToolchain(TestCase): """Test Arm classes.""" @@ -30,6 +31,8 @@ def test_arm_minimal_printf(self): mock_target = mock.MagicMock() mock_target.core = "Cortex-M4" mock_target.printf_lib = "minimal-printf" + mock_target.default_lib = "std" + mock_target.supported_c_libs = {"arm": ["std"]} mock_target.supported_toolchains = ["ARM", "uARM", "ARMC5"] arm_std_obj = ARM_STD(mock_target) @@ -40,6 +43,58 @@ def test_arm_minimal_printf(self): self.assertIn("-DMBED_MINIMAL_PRINTF", arm_micro_obj.flags["common"]) self.assertIn("-DMBED_MINIMAL_PRINTF", arm_c6_obj.flags["common"]) + def test_arm_default_lib(self): + """Test that linker flags are correctly added to an instance of ARM.""" + mock_target = mock.MagicMock() + mock_target.core = "Cortex-M4" + mock_target.supported_c_libs = {"arm": ["small"]} + mock_target.default_lib = "sMALL" + mock_target.default_toolchain = "ARM" + mock_target.supported_toolchains = ["ARM", "uARM", "ARMC5", "ARMC6"] + arm_std_obj = ARM_STD(mock_target) + arm_micro_obj = ARM_MICRO(mock_target) + + mock_target.default_toolchain = "ARMC6" + arm_c6_obj = ARMC6(mock_target) + + self.assertIn("-D__MICROLIB", arm_std_obj.flags["common"]) + self.assertIn("-D__MICROLIB", arm_micro_obj.flags["common"]) + self.assertIn("-D__MICROLIB", arm_c6_obj.flags["common"]) + + self.assertIn("--library_type=microlib", arm_std_obj.flags["ld"]) + self.assertIn("--library_type=microlib", arm_micro_obj.flags["ld"]) + self.assertIn("--library_type=microlib", arm_c6_obj.flags["ld"]) + + self.assertIn("-Wl,--library_type=microlib", arm_c6_obj.flags["cxx"]) + self.assertIn("--library_type=microlib", arm_c6_obj.flags["asm"]) + + def test_arm_default_lib_std_exception(self): + """Test that exception raised when default_lib is std but supported_c_libs parameter arm is not suppoted std lib.""" + mock_target = mock.MagicMock() + mock_target.core = "Cortex-M4" + mock_target.supported_toolchains = ["ARM", "uARM", "ARMC5"] + mock_target.default_toolchain = "ARM" + mock_target.default_lib = "std" + mock_target.supported_c_libs = {"arm": ["small"]} + with self.assertRaisesRegexp(NotSupportedException, UNSUPPORTED_C_LIB_EXECPTION_STRING.format(mock_target.default_lib)): + ARM_STD(mock_target) + with self.assertRaisesRegexp(NotSupportedException, UNSUPPORTED_C_LIB_EXECPTION_STRING.format(mock_target.default_lib)): + ARMC6(mock_target) + + + def test_arm_default_lib_small_exception(self): + """Test that exception raised when default_lib is small but supported_c_libs parameter arm is not suppoted small lib.""" + mock_target = mock.MagicMock() + mock_target.core = "Cortex-M4" + mock_target.default_lib = "small" + mock_target.supported_c_libs = {"arm": ["std"]} + mock_target.default_toolchain = "ARM" + mock_target.supported_toolchains = ["ARM", "uARM", "ARMC5"] + with self.assertRaisesRegexp(NotSupportedException, UNSUPPORTED_C_LIB_EXECPTION_STRING.format(mock_target.default_lib)): + ARM_STD(mock_target) + mock_target.default_toolchain = "ARMC6" + with self.assertRaisesRegexp(NotSupportedException, UNSUPPORTED_C_LIB_EXECPTION_STRING.format(mock_target.default_lib)): + ARMC6(mock_target) class TestGccToolchain(TestCase): """Test the GCC class.""" @@ -50,6 +105,8 @@ def test_gcc_minimal_printf(self): mock_target.core = "Cortex-M4" mock_target.printf_lib = "minimal-printf" mock_target.supported_toolchains = ["GCC_ARM"] + mock_target.default_lib = "std" + mock_target.supported_c_libs = {"gcc_arm": ["std"]} mock_target.is_TrustZone_secure_target = False gcc_obj = GCC_ARM(mock_target) @@ -70,18 +127,88 @@ def test_gcc_minimal_printf(self): for i in minimal_printf_wraps: self.assertIn(i, gcc_obj.flags["ld"]) + def test_gcc_arm_default_lib(self): + """Test that linker flags are correctly added to an instance of GCC_ARM.""" + mock_target = mock.MagicMock() + mock_target.core = "Cortex-M4" + mock_target.supported_c_libs = {"gcc_arm": ["small"]} + mock_target.default_lib = "sMALL" + mock_target.supported_toolchains = ["GCC_ARM"] + mock_target.is_TrustZone_secure_target = False + gcc_arm_obj = GCC_ARM(mock_target) + self.assertIn("-DMBED_RTOS_SINGLE_THREAD", gcc_arm_obj.flags["common"]) + self.assertIn("-D__NEWLIB_NANO", gcc_arm_obj.flags["common"]) + self.assertIn("--specs=nano.specs", gcc_arm_obj.flags["ld"]) + + def test_gcc_arm_default_lib_std_exception(self): + """Test that exception raised when default_lib is std but supported_c_libs parameter arm is not suppoted std lib.""" + mock_target = mock.MagicMock() + mock_target.core = "Cortex-M4" + mock_target.default_toolchain = "ARM" + mock_target.default_lib = "std" + mock_target.supported_c_libs = {"arm": ["small"]} + with self.assertRaisesRegexp(NotSupportedException, UNSUPPORTED_C_LIB_EXECPTION_STRING.format(mock_target.default_lib)): + GCC_ARM(mock_target) + + def test_gcc_arm_default_lib_small_exception(self): + """Test that exception raised when default_lib is small but supported_c_libs parameter arm is not suppoted small lib.""" + mock_target = mock.MagicMock() + mock_target.core = "Cortex-M4" + mock_target.default_lib = "small" + mock_target.supported_c_libs = {"arm": ["std"]} + mock_target.default_toolchain = "ARM" + mock_target.supported_toolchains = ["ARM", "uARM", "ARMC5"] + with self.assertRaisesRegexp(NotSupportedException, UNSUPPORTED_C_LIB_EXECPTION_STRING.format(mock_target.default_lib)): + GCC_ARM(mock_target) class TestIarToolchain(TestCase): """Test the IAR class.""" def test_iar_minimal_printf(self): - """Test that linker flags are correctly added to an instance of GCC_ARM.""" + """Test that linker flags are correctly added to an instance of IAR.""" mock_target = mock.MagicMock() mock_target.core = "Cortex-M4" mock_target.printf_lib = "minimal-printf" mock_target.supported_toolchains = ["IAR"] + mock_target.default_lib = "std" + mock_target.supported_c_libs = {"iar": ["std"]} mock_target.is_TrustZone_secure_target = False iar_obj = IAR(mock_target) var = "-DMBED_MINIMAL_PRINTF" self.assertIn("-DMBED_MINIMAL_PRINTF", iar_obj.flags["common"]) + + def test_iar_default_lib(self): + """Test that linker flags are correctly added to an instance of IAR.""" + mock_target = mock.MagicMock() + mock_target.core = "Cortex-M4" + mock_target.supported_c_libs = {"iar": ["std"]} + mock_target.default_lib = "sTD" + mock_target.supported_toolchains = ["IAR"] + mock_target.is_TrustZone_secure_target = False + try: + IAR(mock_target) + except NotSupportedException: + self.fail(UNSUPPORTED_C_LIB_EXECPTION_STRING.format(mock_target.default_lib)) + + def test_iar_default_lib_std_exception(self): + """Test that exception raised when default_lib is small but supported_c_libs parameter iar is not supported small lib.""" + mock_target = mock.MagicMock() + mock_target.core = "Cortex-M4" + mock_target.microlib_supported = False + mock_target.default_lib = "std" + mock_target.supported_c_libs = {"iar": ["small"]} + mock_target.supported_toolchains = ["IAR"] + with self.assertRaisesRegexp(NotSupportedException, UNSUPPORTED_C_LIB_EXECPTION_STRING.format(mock_target.default_lib)): + IAR(mock_target) + + def test_iar_default_lib_small_exception(self): + """Test that exception raised when default_lib is small but supported_c_libs parameter iar is not supported small lib.""" + mock_target = mock.MagicMock() + mock_target.core = "Cortex-M4" + mock_target.microlib_supported = False + mock_target.default_lib = "small" + mock_target.supported_c_libs = {"iar": ["std"]} + mock_target.supported_toolchains = ["IAR"] + with self.assertRaisesRegexp(NotSupportedException, UNSUPPORTED_C_LIB_EXECPTION_STRING.format(mock_target.default_lib)): + IAR(mock_target) diff --git a/tools/toolchains/arm.py b/tools/toolchains/arm.py index f83bc855054..b0bdf682ae0 100644 --- a/tools/toolchains/arm.py +++ b/tools/toolchains/arm.py @@ -31,12 +31,18 @@ ARMC5_MIGRATION_WARNING = ( "Warning: We noticed that you are using Arm Compiler 5. " - "We are deprecating the use of Arm Compiler 5 soon. " + "We are deprecating the use of Arm Compiler 5. " "Please upgrade your environment to Arm Compiler 6 " "which is free to use with Mbed OS. For more information, " "please visit https://os.mbed.com/docs/mbed-os/latest/tools/index.html" ) +UARM_TOOLCHAIN_WARNING = ( + "Warning: We noticed that you are using uARM Toolchain. " + "We are deprecating the uARM Toolchain. " + "For more information on how to use the ARM toolchain with small C libraries, " + "please visit https://os.mbed.com/docs/mbed-os/latest/reference/using-small-c-libraries.html" +) class ARM(mbedToolchain): LINKER_EXT = '.sct' @@ -71,7 +77,9 @@ def __init__(self, target, notify=None, macros=None, raise NotSupportedException( "this compiler does not support the core %s" % target.core) - if getattr(target, "default_toolchain", "ARM") == "uARM": + self.check_c_lib_supported(target, "arm") + + if getattr(target, "default_toolchain", "ARM") == "uARM" or getattr(target, "default_lib", "std") == "small": if "-DMBED_RTOS_SINGLE_THREAD" not in self.flags['common']: self.flags['common'].append("-DMBED_RTOS_SINGLE_THREAD") if "-D__MICROLIB" not in self.flags['common']: @@ -556,7 +564,9 @@ def __init__(self, target, *args, **kwargs): "ARM/ARMC6 compiler support is required for ARMC6 build" ) - if getattr(target, "default_toolchain", "ARMC6") == "uARM": + self.check_c_lib_supported(target, "arm") + + if getattr(target, "default_toolchain", "ARMC6") == "uARM" or getattr(target, "default_lib", "std") == "small": if "-DMBED_RTOS_SINGLE_THREAD" not in self.flags['common']: self.flags['common'].append("-DMBED_RTOS_SINGLE_THREAD") if "-D__MICROLIB" not in self.flags['common']: diff --git a/tools/toolchains/gcc.py b/tools/toolchains/gcc.py index bc3b5987853..c205f05896a 100644 --- a/tools/toolchains/gcc.py +++ b/tools/toolchains/gcc.py @@ -48,14 +48,16 @@ def __init__(self, target, notify=None, macros=None, build_profile=None, tool_path = TOOLCHAIN_PATHS['GCC_ARM'] # Add flags for current size setting - default_lib = "std" + default_lib = "" if hasattr(target, "default_lib"): + self.check_c_lib_supported(target, "gcc_arm") default_lib = target.default_lib elif hasattr(target, "default_build"): default_lib = target.default_build if default_lib == "small": - self.flags["common"].append("-DMBED_RTOS_SINGLE_THREAD") + common_flags = ["-DMBED_RTOS_SINGLE_THREAD", "-D__NEWLIB_NANO"] + self.flags["common"].extend(common_flags) self.flags["ld"].append("--specs=nano.specs") self.check_and_add_minimal_printf(target) diff --git a/tools/toolchains/iar.py b/tools/toolchains/iar.py index 8d80e4040a4..e5b65b24857 100644 --- a/tools/toolchains/iar.py +++ b/tools/toolchains/iar.py @@ -22,7 +22,6 @@ from tools.toolchains.mbed_toolchain import mbedToolchain, TOOLCHAIN_PATHS from tools.utils import run_cmd - class IAR(mbedToolchain): OFFICIALLY_SUPPORTED = True LIBRARY_EXT = '.a' @@ -54,6 +53,8 @@ def __init__(self, target, notify=None, macros=None, build_profile=None, build_profile=build_profile ) + self.check_c_lib_supported(target, "iar") + if target.is_TrustZone_secure_target: # Enable compiler security extensions self.flags["asm"] += ["--cmse"] diff --git a/tools/toolchains/mbed_toolchain.py b/tools/toolchains/mbed_toolchain.py index 8c8dbf76bb7..d99b07c755b 100755 --- a/tools/toolchains/mbed_toolchain.py +++ b/tools/toolchains/mbed_toolchain.py @@ -109,6 +109,7 @@ "__MBED_CMSIS_RTOS_CM", "__DSP_PRESENT=1U"], } +UNSUPPORTED_C_LIB_EXECPTION_STRING = "{} C library option not supported for this target." class mbedToolchain(with_metaclass(ABCMeta, object)): OFFICIALLY_SUPPORTED = False @@ -1098,6 +1099,24 @@ def check_and_add_minimal_printf(self, target): ): self.flags["common"].append("-DMBED_MINIMAL_PRINTF") + def check_c_lib_supported(self, target, toolchain): + """ + Check and raise an exception if the requested C library is not supported, + + target.default_lib is modified to have the lowercased string of its original string. + This is done to be case insensitvie when validating. + """ + if hasattr(target, "default_lib"): + target.default_lib = target.default_lib.lower() + if ( + hasattr(target, "supported_c_libs") == False + or toolchain not in target.supported_c_libs + or target.default_lib not in target.supported_c_libs[toolchain] + ): + raise NotSupportedException( + UNSUPPORTED_C_LIB_EXECPTION_STRING.format(target.default_lib) + ) + @staticmethod def _overwrite_when_not_equal(filename, content): if not exists(filename) or content != open(filename).read(): From 6d081eeb705ca1e7a6cc70252c7e22de5d30e10f Mon Sep 17 00:00:00 2001 From: Rajkumar Kanagaraj Date: Tue, 10 Dec 2019 09:20:34 -0800 Subject: [PATCH 2/4] Fixed the build tools test case failure,incorporated review comments --- TESTS/configs/baremetal.json | 19 ++++++++++- TESTS/mbed_drivers/c_strings/main.cpp | 2 ++ .../minimal-printf/compliance/main.cpp | 16 +++++++++ targets/targets.json | 14 ++------ .../config/app_override_libs/targets.json | 7 +++- .../config/compound_inheritance/targets.json | 5 +++ tools/test/config/double_define/targets.json | 10 ++++++ .../config/feature_compesition/targets.json | 7 +++- .../config/feature_recursive_add/targets.json | 7 +++- .../feature_recursive_complex/targets.json | 7 +++- tools/test/config/feature_remove/targets.json | 7 +++- .../lib_requires_missing_lib/targets.json | 7 +++- .../config/macro_inheritance/targets.json | 7 +++- .../config/override_labels_libs/targets.json | 5 +++ .../override_labels_libs_more/targets.json | 5 +++ .../override_labels_targets/targets.json | 5 +++ .../config/override_precidence/targets.json | 5 +++ .../config/override_undefined/targets.json | 5 +++ .../override_undefined_libs/targets.json | 5 +++ .../config/override_with_labels/targets.json | 5 +++ tools/test/config/range_limits/targets.json | 5 +++ .../config/range_limits_invalid/targets.json | 7 +++- .../targets.json | 5 +++ .../requires_exclude_in_include/targets.json | 14 ++++++-- .../config/requires_from_lib/targets.json | 7 +++- .../requires_include_in_exclude/targets.json | 14 ++++++-- .../config/requires_omit_lib/targets.json | 14 ++++++-- .../test/config/simple_features/targets.json | 7 +++- .../config/simple_iheritance/targets.json | 5 +++ tools/test/targets/target_test.py | 12 ++++++- ...ludes_d41d8cd98f00b204e9800998ecf8427e.txt | 0 ...acros_d41d8cd98f00b204e9800998ecf8427e.xcl | 0 tools/test/toolchains/test_toolchains.py | 34 +++++++++---------- tools/toolchains/arm.py | 12 +++++-- tools/toolchains/gcc.py | 2 +- tools/toolchains/mbed_toolchain.py | 6 ++-- 36 files changed, 240 insertions(+), 54 deletions(-) delete mode 100644 tools/test/toolchains/.includes_d41d8cd98f00b204e9800998ecf8427e.txt delete mode 100644 tools/test/toolchains/asm_macros_d41d8cd98f00b204e9800998ecf8427e.xcl diff --git a/TESTS/configs/baremetal.json b/TESTS/configs/baremetal.json index 6bbfb1edf07..9d6963cac65 100644 --- a/TESTS/configs/baremetal.json +++ b/TESTS/configs/baremetal.json @@ -36,8 +36,25 @@ ], "target_overrides": { "*": { - "target.default_lib": "small", "mbed-trace.fea-ipv6": false + }, + "K64F": { + "target.default_lib": "small" + }, + "K66F": { + "target.default_lib": "small" + }, + "NUCLEO_F303RE": { + "target.default_lib": "small" + }, + "NUCLEO_F411RE": { + "target.default_lib": "small" + }, + "NUCLEO_F429ZI": { + "target.default_lib": "small" + }, + "DISCO_L475VG_IOT01A": { + "target.default_lib": "small" } } } diff --git a/TESTS/mbed_drivers/c_strings/main.cpp b/TESTS/mbed_drivers/c_strings/main.cpp index d0a6666965a..9b79f2bd9ee 100644 --- a/TESTS/mbed_drivers/c_strings/main.cpp +++ b/TESTS/mbed_drivers/c_strings/main.cpp @@ -116,6 +116,8 @@ Case cases[] = { Case("C strings: %u %d integer formatting", test_case_c_string_u_d, greentea_failure_handler), Case("C strings: %x %E integer formatting", test_case_c_string_x_X, greentea_failure_handler), #if !defined(__NEWLIB_NANO) + //In build tools, GCC with Newlib-nano linker option "-u _printf_float" is not configured + //to enable printf floating format. So disabling floating format test case. Case("C strings: %f %f float formatting", test_case_c_string_f_f, greentea_failure_handler), #ifndef MBED_MINIMAL_PRINTF Case("C strings: %e %E float formatting", test_case_c_string_e_E, greentea_failure_handler), diff --git a/TESTS/mbed_platform/minimal-printf/compliance/main.cpp b/TESTS/mbed_platform/minimal-printf/compliance/main.cpp index e996d71aee1..5660e7c1d8d 100644 --- a/TESTS/mbed_platform/minimal-printf/compliance/main.cpp +++ b/TESTS/mbed_platform/minimal-printf/compliance/main.cpp @@ -52,6 +52,7 @@ static control_t test_printf_d(const size_t call_count) /*************************************************************************/ /*************************************************************************/ #if !defined(__NEWLIB_NANO) + // The format specifier %hhd is not supported by Newlib-Nano result_minimal = mbed_printf("hhd: %hhd\r\n", SCHAR_MIN); result_file = mbed_fprintf(stderr, "hhd: %hhd\r\n", SCHAR_MIN); result_baseline = printf("hhd: %hhd\r\n", SCHAR_MIN); @@ -102,6 +103,7 @@ static control_t test_printf_d(const size_t call_count) TEST_ASSERT_EQUAL_INT(result_baseline, result_file); #if !defined(__NEWLIB_NANO) + // The format specifier %lld is not supported by Newlib-Nano result_minimal = mbed_printf("lld: %lld\r\n", LLONG_MIN); result_file = mbed_fprintf(stderr, "lld: %lld\r\n", LLONG_MIN); result_baseline = printf("lld: %lld\r\n", LLONG_MIN); @@ -175,6 +177,7 @@ static control_t test_printf_u(const size_t call_count) /*************************************************************************/ /*************************************************************************/ #if !defined(__NEWLIB_NANO) + // The format specifier %hhu is not supported by Newlib-Nano result_minimal = mbed_printf("hhu: %hhu\r\n", 0); result_file = mbed_fprintf(stderr, "hhu: %hhu\r\n", 0); result_baseline = printf("hhu: %hhu\r\n", 0); @@ -224,6 +227,7 @@ static control_t test_printf_u(const size_t call_count) TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); #if !defined(__NEWLIB_NANO) + // The format specifier %llu is not supported by Newlib-Nano result_minimal = mbed_printf("llu: %llu\r\n", 0ULL); result_file = mbed_fprintf(stderr, "llu: %llu\r\n", 0ULL); result_baseline = printf("llu: %llu\r\n", 0ULL); @@ -297,6 +301,7 @@ static control_t test_printf_x(const size_t call_count) /*************************************************************************/ /*************************************************************************/ #if !defined(__NEWLIB_NANO) + // The format specifier %hhX is not supported by Newlib-Nano result_minimal = mbed_printf("hhX: %hhX\r\n", 0); result_file = mbed_fprintf(stderr, "hhX: %hhX\r\n", 0); result_baseline = printf("hhX: %hhX\r\n", 0); @@ -346,6 +351,7 @@ static control_t test_printf_x(const size_t call_count) TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); #if !defined(__NEWLIB_NANO) + // The format specifier %llX is not supported by Newlib-Nano result_minimal = mbed_printf("llX: %llX\r\n", 0ULL); result_file = mbed_fprintf(stderr, "llX: %llX\r\n", 0ULL); result_baseline = printf("llX: %llX\r\n", 0ULL); @@ -445,6 +451,7 @@ static control_t test_snprintf_d(const size_t call_count) /*************************************************************************/ /*************************************************************************/ #if !defined(__NEWLIB_NANO) + // The format specifier %hhd is not supported by Newlib-Nano result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hhd: %hhd\r\n", SCHAR_MIN); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hhd: %hhd\r\n", SCHAR_MIN); TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); @@ -487,6 +494,7 @@ static control_t test_snprintf_d(const size_t call_count) TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); #if !defined(__NEWLIB_NANO) + // The format specifier %lld is not supported by Newlib-Nano result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "lld: %lld\r\n", LLONG_MIN); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "lld: %lld\r\n", LLONG_MIN); TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); @@ -553,6 +561,7 @@ static control_t test_snprintf_u(const size_t call_count) /*************************************************************************/ /*************************************************************************/ #if !defined(__NEWLIB_NANO) + // The format specifier %hhu is not supported by Newlib-Nano result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hhu: %hhu\r\n", 0); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hhu: %hhu\r\n", 0); TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); @@ -594,6 +603,7 @@ static control_t test_snprintf_u(const size_t call_count) TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); #if !defined(__NEWLIB_NANO) + // The format specifier %llu is not supported by Newlib-Nano result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "llu: %llu\r\n", 0ULL); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "llu: %llu\r\n", 0ULL); TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); @@ -660,6 +670,7 @@ static control_t test_snprintf_x(const size_t call_count) /*************************************************************************/ /*************************************************************************/ #if !defined(__NEWLIB_NANO) + // The format specifier %hhX is not supported by Newlib-Nano result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hhX: %hhX\r\n", 0); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hhX: %hhX\r\n", 0); TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); @@ -700,6 +711,7 @@ static control_t test_snprintf_x(const size_t call_count) TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); #if !defined(__NEWLIB_NANO) + // The format specifier %llX is not supported by Newlib-Nano result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "llX: %llX\r\n", 0ULL); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "llX: %llX\r\n", 0ULL); TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); @@ -923,6 +935,7 @@ static control_t test_snprintf_buffer_overflow_ld(const size_t call_count) } #if !defined(__NEWLIB_NANO) +// The format specifier %lld is not supported by Newlib-Nano static control_t test_snprintf_buffer_overflow_lld(const size_t call_count) { return test_snprintf_buffer_overflow_generic("lld: %lld", -1099511627776LL); @@ -940,6 +953,7 @@ static control_t test_snprintf_buffer_overflow_lu(const size_t call_count) } #if !defined(__NEWLIB_NANO) +// The format specifier %llu is not supported by Newlib-Nano static control_t test_snprintf_buffer_overflow_llu(const size_t call_count) { return test_snprintf_buffer_overflow_generic("llu: %llu", 1099511627776ULL); @@ -957,6 +971,7 @@ static control_t test_snprintf_buffer_overflow_lx(const size_t call_count) } #if !defined(__NEWLIB_NANO) +// The format specifier %llx is not supported by Newlib-Nano static control_t test_snprintf_buffer_overflow_llx(const size_t call_count) { return test_snprintf_buffer_overflow_generic("llx: 0x%llx", 0x10000000000ULL); @@ -990,6 +1005,7 @@ Case cases[] = { Case("snprintf buffer overflow %x", test_snprintf_buffer_overflow_x), Case("snprintf buffer overflow %lx", test_snprintf_buffer_overflow_lx), #if !defined(__NEWLIB_NANO) + // The format specifiers %lld,%llu,%llx are not supported by Newlib-Nano Case("snprintf buffer overflow %lld", test_snprintf_buffer_overflow_lld), Case("snprintf buffer overflow %llu", test_snprintf_buffer_overflow_llu), Case("snprintf buffer overflow %llx", test_snprintf_buffer_overflow_llx), diff --git a/targets/targets.json b/targets/targets.json index a2029e467be..4148fd64990 100644 --- a/targets/targets.json +++ b/targets/targets.json @@ -2136,12 +2136,7 @@ "init-us-ticker-at-boot": true }, "OUTPUT_EXT": "hex", - "bootloader_supported": true, - "supported_c_libs": { - "arm": ["std", "small"], - "gcc_arm": ["std", "small"], - "iar": ["std"] - } + "bootloader_supported": true }, "LPC55S69_S": { "inherits": ["SPE_Target", "LPC55S69"], @@ -3569,12 +3564,7 @@ ], "release_versions": ["2", "5"], "bootloader_supported": true, - "device_name": "STM32L073RZ", - "supported_c_libs": { - "arm": ["std", "small"], - "gcc_arm": ["std", "small"], - "iar": ["std"] - } + "device_name": "STM32L073RZ" }, "NUCLEO_L152RE": { "inherits": ["FAMILY_STM32"], diff --git a/tools/test/config/app_override_libs/targets.json b/tools/test/config/app_override_libs/targets.json index e2b21623dc7..f6b8239488b 100644 --- a/tools/test/config/app_override_libs/targets.json +++ b/tools/test/config/app_override_libs/targets.json @@ -4,6 +4,11 @@ "extra_labels": [], "features": [], "default_lib": "std", - "supported_toolchains": ["GCC_ARM"] + "supported_toolchains": ["GCC_ARM"], + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + } } } diff --git a/tools/test/config/compound_inheritance/targets.json b/tools/test/config/compound_inheritance/targets.json index ce17a62c639..d4c690afd4a 100644 --- a/tools/test/config/compound_inheritance/targets.json +++ b/tools/test/config/compound_inheritance/targets.json @@ -3,6 +3,11 @@ "supported_toolchains": ["GCC_ARM"], "extra_labels": [], "default_lib": "std", + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + }, "core": "Cortex-M0", "config": { "base1_1": "v_base1_1_b1", diff --git a/tools/test/config/double_define/targets.json b/tools/test/config/double_define/targets.json index b1310a19ceb..258fa4660ec 100644 --- a/tools/test/config/double_define/targets.json +++ b/tools/test/config/double_define/targets.json @@ -3,6 +3,11 @@ "supported_toolchains": ["GCC_ARM"], "extra_labels": [], "default_lib": "std", + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + }, "core": "Cortex-M0", "config": { "base1_1": "v_base1_1_b1", @@ -14,6 +19,11 @@ "supported_toolchains": ["GCC_ARM"], "extra_labels": [], "default_lib": "std", + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + }, "core": "Cortex-M0", "config": { "base2_1": "v_base2_1_b2", diff --git a/tools/test/config/feature_compesition/targets.json b/tools/test/config/feature_compesition/targets.json index a4909c35301..33cdaf0c683 100644 --- a/tools/test/config/feature_compesition/targets.json +++ b/tools/test/config/feature_compesition/targets.json @@ -4,6 +4,11 @@ "core": "Cortex-M0", "extra_labels": [], "features": [], - "default_lib": "std" + "default_lib": "std", + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + } } } diff --git a/tools/test/config/feature_recursive_add/targets.json b/tools/test/config/feature_recursive_add/targets.json index a4909c35301..33cdaf0c683 100644 --- a/tools/test/config/feature_recursive_add/targets.json +++ b/tools/test/config/feature_recursive_add/targets.json @@ -4,6 +4,11 @@ "core": "Cortex-M0", "extra_labels": [], "features": [], - "default_lib": "std" + "default_lib": "std", + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + } } } diff --git a/tools/test/config/feature_recursive_complex/targets.json b/tools/test/config/feature_recursive_complex/targets.json index a4909c35301..33cdaf0c683 100644 --- a/tools/test/config/feature_recursive_complex/targets.json +++ b/tools/test/config/feature_recursive_complex/targets.json @@ -4,6 +4,11 @@ "core": "Cortex-M0", "extra_labels": [], "features": [], - "default_lib": "std" + "default_lib": "std", + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + } } } diff --git a/tools/test/config/feature_remove/targets.json b/tools/test/config/feature_remove/targets.json index 39a077314de..d60172f623d 100644 --- a/tools/test/config/feature_remove/targets.json +++ b/tools/test/config/feature_remove/targets.json @@ -4,6 +4,11 @@ "core": "Cortex-M0", "extra_labels": [], "features": ["BOOTLOADER"], - "default_lib": "std" + "default_lib": "std", + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + } } } diff --git a/tools/test/config/lib_requires_missing_lib/targets.json b/tools/test/config/lib_requires_missing_lib/targets.json index a4909c35301..33cdaf0c683 100644 --- a/tools/test/config/lib_requires_missing_lib/targets.json +++ b/tools/test/config/lib_requires_missing_lib/targets.json @@ -4,6 +4,11 @@ "core": "Cortex-M0", "extra_labels": [], "features": [], - "default_lib": "std" + "default_lib": "std", + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + } } } diff --git a/tools/test/config/macro_inheritance/targets.json b/tools/test/config/macro_inheritance/targets.json index a4909c35301..33cdaf0c683 100644 --- a/tools/test/config/macro_inheritance/targets.json +++ b/tools/test/config/macro_inheritance/targets.json @@ -4,6 +4,11 @@ "core": "Cortex-M0", "extra_labels": [], "features": [], - "default_lib": "std" + "default_lib": "std", + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + } } } diff --git a/tools/test/config/override_labels_libs/targets.json b/tools/test/config/override_labels_libs/targets.json index 18deeb9467a..6556e9f7f36 100644 --- a/tools/test/config/override_labels_libs/targets.json +++ b/tools/test/config/override_labels_libs/targets.json @@ -3,6 +3,11 @@ "supported_toolchains": ["GCC_ARM"], "extra_labels": [], "default_lib": "std", + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + }, "core": "Cortex-M0" }, "b1": { diff --git a/tools/test/config/override_labels_libs_more/targets.json b/tools/test/config/override_labels_libs_more/targets.json index 18deeb9467a..6556e9f7f36 100644 --- a/tools/test/config/override_labels_libs_more/targets.json +++ b/tools/test/config/override_labels_libs_more/targets.json @@ -3,6 +3,11 @@ "supported_toolchains": ["GCC_ARM"], "extra_labels": [], "default_lib": "std", + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + }, "core": "Cortex-M0" }, "b1": { diff --git a/tools/test/config/override_labels_targets/targets.json b/tools/test/config/override_labels_targets/targets.json index ab0329f18cd..866972f5f87 100644 --- a/tools/test/config/override_labels_targets/targets.json +++ b/tools/test/config/override_labels_targets/targets.json @@ -3,6 +3,11 @@ "supported_toolchains": ["GCC_ARM"], "extra_labels": [], "default_lib": "std", + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + }, "core": "Cortex-M0", "config": { "par1": "v_par1_base", diff --git a/tools/test/config/override_precidence/targets.json b/tools/test/config/override_precidence/targets.json index ab0329f18cd..ebb4b1bdffa 100644 --- a/tools/test/config/override_precidence/targets.json +++ b/tools/test/config/override_precidence/targets.json @@ -8,6 +8,11 @@ "par1": "v_par1_base", "par2": "v_par2_base", "par3": "v_par3_base" + }, + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] } }, "b1": { diff --git a/tools/test/config/override_undefined/targets.json b/tools/test/config/override_undefined/targets.json index f62e4d5e270..a30f2bc00ba 100644 --- a/tools/test/config/override_undefined/targets.json +++ b/tools/test/config/override_undefined/targets.json @@ -3,6 +3,11 @@ "supported_toolchains": ["GCC_ARM"], "extra_labels": [], "default_lib": "std", + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + }, "core": "Cortex-M0", "config": { "base1_1": "v_base1_1_b1", diff --git a/tools/test/config/override_undefined_libs/targets.json b/tools/test/config/override_undefined_libs/targets.json index 72b743f5abb..bcbc77d5a3c 100644 --- a/tools/test/config/override_undefined_libs/targets.json +++ b/tools/test/config/override_undefined_libs/targets.json @@ -3,6 +3,11 @@ "supported_toolchains": ["GCC_ARM"], "extra_labels": [], "default_lib": "std", + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + }, "core": "Cortex-M0" }, "left_intermediate": { diff --git a/tools/test/config/override_with_labels/targets.json b/tools/test/config/override_with_labels/targets.json index 11ffbb6b045..095f989a99d 100644 --- a/tools/test/config/override_with_labels/targets.json +++ b/tools/test/config/override_with_labels/targets.json @@ -3,6 +3,11 @@ "supported_toolchains": ["GCC_ARM"], "extra_labels": [], "default_lib": "std", + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + }, "core": "Cortex-M0" }, "left_intermediate": { diff --git a/tools/test/config/range_limits/targets.json b/tools/test/config/range_limits/targets.json index e2b21623dc7..adacab766f8 100644 --- a/tools/test/config/range_limits/targets.json +++ b/tools/test/config/range_limits/targets.json @@ -4,6 +4,11 @@ "extra_labels": [], "features": [], "default_lib": "std", + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + }, "supported_toolchains": ["GCC_ARM"] } } diff --git a/tools/test/config/range_limits_invalid/targets.json b/tools/test/config/range_limits_invalid/targets.json index e2b21623dc7..f6b8239488b 100644 --- a/tools/test/config/range_limits_invalid/targets.json +++ b/tools/test/config/range_limits_invalid/targets.json @@ -4,6 +4,11 @@ "extra_labels": [], "features": [], "default_lib": "std", - "supported_toolchains": ["GCC_ARM"] + "supported_toolchains": ["GCC_ARM"], + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + } } } diff --git a/tools/test/config/range_limits_override_invalid/targets.json b/tools/test/config/range_limits_override_invalid/targets.json index e2b21623dc7..adacab766f8 100644 --- a/tools/test/config/range_limits_override_invalid/targets.json +++ b/tools/test/config/range_limits_override_invalid/targets.json @@ -4,6 +4,11 @@ "extra_labels": [], "features": [], "default_lib": "std", + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + }, "supported_toolchains": ["GCC_ARM"] } } diff --git a/tools/test/config/requires_exclude_in_include/targets.json b/tools/test/config/requires_exclude_in_include/targets.json index 40ff29520d4..24f496a0f6a 100644 --- a/tools/test/config/requires_exclude_in_include/targets.json +++ b/tools/test/config/requires_exclude_in_include/targets.json @@ -4,13 +4,23 @@ "core": "Cortex-M0", "extra_labels": [], "features": [], - "default_lib": "std" + "default_lib": "std", + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + } }, "should_pass": { "supported_toolchains": ["GCC_ARM"], "core": "Cortex-M0", "extra_labels": [], "features": [], - "default_lib": "std" + "default_lib": "std", + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + } } } diff --git a/tools/test/config/requires_from_lib/targets.json b/tools/test/config/requires_from_lib/targets.json index a4909c35301..33cdaf0c683 100644 --- a/tools/test/config/requires_from_lib/targets.json +++ b/tools/test/config/requires_from_lib/targets.json @@ -4,6 +4,11 @@ "core": "Cortex-M0", "extra_labels": [], "features": [], - "default_lib": "std" + "default_lib": "std", + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + } } } diff --git a/tools/test/config/requires_include_in_exclude/targets.json b/tools/test/config/requires_include_in_exclude/targets.json index 40ff29520d4..24f496a0f6a 100644 --- a/tools/test/config/requires_include_in_exclude/targets.json +++ b/tools/test/config/requires_include_in_exclude/targets.json @@ -4,13 +4,23 @@ "core": "Cortex-M0", "extra_labels": [], "features": [], - "default_lib": "std" + "default_lib": "std", + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + } }, "should_pass": { "supported_toolchains": ["GCC_ARM"], "core": "Cortex-M0", "extra_labels": [], "features": [], - "default_lib": "std" + "default_lib": "std", + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + } } } diff --git a/tools/test/config/requires_omit_lib/targets.json b/tools/test/config/requires_omit_lib/targets.json index 40ff29520d4..24f496a0f6a 100644 --- a/tools/test/config/requires_omit_lib/targets.json +++ b/tools/test/config/requires_omit_lib/targets.json @@ -4,13 +4,23 @@ "core": "Cortex-M0", "extra_labels": [], "features": [], - "default_lib": "std" + "default_lib": "std", + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + } }, "should_pass": { "supported_toolchains": ["GCC_ARM"], "core": "Cortex-M0", "extra_labels": [], "features": [], - "default_lib": "std" + "default_lib": "std", + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + } } } diff --git a/tools/test/config/simple_features/targets.json b/tools/test/config/simple_features/targets.json index a4909c35301..33cdaf0c683 100644 --- a/tools/test/config/simple_features/targets.json +++ b/tools/test/config/simple_features/targets.json @@ -4,6 +4,11 @@ "core": "Cortex-M0", "extra_labels": [], "features": [], - "default_lib": "std" + "default_lib": "std", + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + } } } diff --git a/tools/test/config/simple_iheritance/targets.json b/tools/test/config/simple_iheritance/targets.json index 8e6dfdd39f4..7cd5383024f 100644 --- a/tools/test/config/simple_iheritance/targets.json +++ b/tools/test/config/simple_iheritance/targets.json @@ -3,6 +3,11 @@ "supported_toolchains": ["GCC_ARM"], "extra_labels": [], "default_lib": "std", + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + }, "core": "Cortex-M0", "config": { "base1_1": "v_base1_1_b1", diff --git a/tools/test/targets/target_test.py b/tools/test/targets/target_test.py index da9ba91fa84..341186aa934 100644 --- a/tools/test/targets/target_test.py +++ b/tools/test/targets/target_test.py @@ -103,6 +103,11 @@ def test_modify_existing_target(): "detect_code": [], "public": false, "default_lib": "std", + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + }, "bootloader_supported": false }, "Test_Target": { @@ -113,7 +118,7 @@ def test_modify_existing_target(): }""" test_target_json = """ - { + { "Target": { "core": "Cortex-M0", "default_toolchain": "GCC_ARM", @@ -126,6 +131,11 @@ def test_modify_existing_target(): "detect_code": [], "public": false, "default_lib": "std", + "supported_c_libs": { + "arm": ["std"], + "gcc_arm": ["std", "small"], + "iar": ["std"] + }, "bootloader_supported": true } } diff --git a/tools/test/toolchains/.includes_d41d8cd98f00b204e9800998ecf8427e.txt b/tools/test/toolchains/.includes_d41d8cd98f00b204e9800998ecf8427e.txt deleted file mode 100644 index e69de29bb2d..00000000000 diff --git a/tools/test/toolchains/asm_macros_d41d8cd98f00b204e9800998ecf8427e.xcl b/tools/test/toolchains/asm_macros_d41d8cd98f00b204e9800998ecf8427e.xcl deleted file mode 100644 index e69de29bb2d..00000000000 diff --git a/tools/test/toolchains/test_toolchains.py b/tools/test/toolchains/test_toolchains.py index 500077dbad2..d7877a74d8b 100644 --- a/tools/test/toolchains/test_toolchains.py +++ b/tools/test/toolchains/test_toolchains.py @@ -20,7 +20,7 @@ from tools.toolchains.arm import ARM_STD, ARM_MICRO, ARMC6 from tools.toolchains.gcc import GCC_ARM from tools.toolchains.iar import IAR -from tools.toolchains.mbed_toolchain import UNSUPPORTED_C_LIB_EXECPTION_STRING +from tools.toolchains.mbed_toolchain import UNSUPPORTED_C_LIB_EXCEPTION_STRING from tools.utils import NotSupportedException class TestArmToolchain(TestCase): @@ -69,31 +69,31 @@ def test_arm_default_lib(self): self.assertIn("--library_type=microlib", arm_c6_obj.flags["asm"]) def test_arm_default_lib_std_exception(self): - """Test that exception raised when default_lib is std but supported_c_libs parameter arm is not suppoted std lib.""" + """Test that an exception is raised if the std C library is not supported for a target on the ARM toolchain.""" mock_target = mock.MagicMock() mock_target.core = "Cortex-M4" mock_target.supported_toolchains = ["ARM", "uARM", "ARMC5"] mock_target.default_toolchain = "ARM" mock_target.default_lib = "std" mock_target.supported_c_libs = {"arm": ["small"]} - with self.assertRaisesRegexp(NotSupportedException, UNSUPPORTED_C_LIB_EXECPTION_STRING.format(mock_target.default_lib)): + with self.assertRaisesRegexp(NotSupportedException, UNSUPPORTED_C_LIB_EXCEPTION_STRING.format(mock_target.default_lib)): ARM_STD(mock_target) - with self.assertRaisesRegexp(NotSupportedException, UNSUPPORTED_C_LIB_EXECPTION_STRING.format(mock_target.default_lib)): + with self.assertRaisesRegexp(NotSupportedException, UNSUPPORTED_C_LIB_EXCEPTION_STRING.format(mock_target.default_lib)): ARMC6(mock_target) def test_arm_default_lib_small_exception(self): - """Test that exception raised when default_lib is small but supported_c_libs parameter arm is not suppoted small lib.""" + """Test that an exception is raised if the small C library is not supported for a target on the ARM toolchain.""" mock_target = mock.MagicMock() mock_target.core = "Cortex-M4" mock_target.default_lib = "small" mock_target.supported_c_libs = {"arm": ["std"]} mock_target.default_toolchain = "ARM" mock_target.supported_toolchains = ["ARM", "uARM", "ARMC5"] - with self.assertRaisesRegexp(NotSupportedException, UNSUPPORTED_C_LIB_EXECPTION_STRING.format(mock_target.default_lib)): + with self.assertRaisesRegexp(NotSupportedException, UNSUPPORTED_C_LIB_EXCEPTION_STRING.format(mock_target.default_lib)): ARM_STD(mock_target) mock_target.default_toolchain = "ARMC6" - with self.assertRaisesRegexp(NotSupportedException, UNSUPPORTED_C_LIB_EXECPTION_STRING.format(mock_target.default_lib)): + with self.assertRaisesRegexp(NotSupportedException, UNSUPPORTED_C_LIB_EXCEPTION_STRING.format(mock_target.default_lib)): ARMC6(mock_target) class TestGccToolchain(TestCase): @@ -141,24 +141,24 @@ def test_gcc_arm_default_lib(self): self.assertIn("--specs=nano.specs", gcc_arm_obj.flags["ld"]) def test_gcc_arm_default_lib_std_exception(self): - """Test that exception raised when default_lib is std but supported_c_libs parameter arm is not suppoted std lib.""" + """Test that an exception is raised if the std C library is not supported for a target on the GCC_ARM toolchain.""" mock_target = mock.MagicMock() mock_target.core = "Cortex-M4" mock_target.default_toolchain = "ARM" mock_target.default_lib = "std" mock_target.supported_c_libs = {"arm": ["small"]} - with self.assertRaisesRegexp(NotSupportedException, UNSUPPORTED_C_LIB_EXECPTION_STRING.format(mock_target.default_lib)): + with self.assertRaisesRegexp(NotSupportedException, UNSUPPORTED_C_LIB_EXCEPTION_STRING.format(mock_target.default_lib)): GCC_ARM(mock_target) def test_gcc_arm_default_lib_small_exception(self): - """Test that exception raised when default_lib is small but supported_c_libs parameter arm is not suppoted small lib.""" + """Test that an exception is raised if the small C library is not supported for a target on the GCC_ARM toolchain.""" mock_target = mock.MagicMock() mock_target.core = "Cortex-M4" mock_target.default_lib = "small" mock_target.supported_c_libs = {"arm": ["std"]} mock_target.default_toolchain = "ARM" mock_target.supported_toolchains = ["ARM", "uARM", "ARMC5"] - with self.assertRaisesRegexp(NotSupportedException, UNSUPPORTED_C_LIB_EXECPTION_STRING.format(mock_target.default_lib)): + with self.assertRaisesRegexp(NotSupportedException, UNSUPPORTED_C_LIB_EXCEPTION_STRING.format(mock_target.default_lib)): GCC_ARM(mock_target) class TestIarToolchain(TestCase): @@ -179,7 +179,7 @@ def test_iar_minimal_printf(self): self.assertIn("-DMBED_MINIMAL_PRINTF", iar_obj.flags["common"]) def test_iar_default_lib(self): - """Test that linker flags are correctly added to an instance of IAR.""" + """Test that no exception is raised when a supported c library is specified.""" mock_target = mock.MagicMock() mock_target.core = "Cortex-M4" mock_target.supported_c_libs = {"iar": ["std"]} @@ -189,26 +189,26 @@ def test_iar_default_lib(self): try: IAR(mock_target) except NotSupportedException: - self.fail(UNSUPPORTED_C_LIB_EXECPTION_STRING.format(mock_target.default_lib)) + self.fail(UNSUPPORTED_C_LIB_EXCEPTION_STRING.format(mock_target.default_lib)) def test_iar_default_lib_std_exception(self): - """Test that exception raised when default_lib is small but supported_c_libs parameter iar is not supported small lib.""" + """Test that an exception is raised if the std C library is not supported for a target on the IAR toolchain.""" mock_target = mock.MagicMock() mock_target.core = "Cortex-M4" mock_target.microlib_supported = False mock_target.default_lib = "std" mock_target.supported_c_libs = {"iar": ["small"]} mock_target.supported_toolchains = ["IAR"] - with self.assertRaisesRegexp(NotSupportedException, UNSUPPORTED_C_LIB_EXECPTION_STRING.format(mock_target.default_lib)): + with self.assertRaisesRegexp(NotSupportedException, UNSUPPORTED_C_LIB_EXCEPTION_STRING.format(mock_target.default_lib)): IAR(mock_target) def test_iar_default_lib_small_exception(self): - """Test that exception raised when default_lib is small but supported_c_libs parameter iar is not supported small lib.""" + """Test that an exception is raised if the small C library is not supported for a target on the IAR toolchain.""" mock_target = mock.MagicMock() mock_target.core = "Cortex-M4" mock_target.microlib_supported = False mock_target.default_lib = "small" mock_target.supported_c_libs = {"iar": ["std"]} mock_target.supported_toolchains = ["IAR"] - with self.assertRaisesRegexp(NotSupportedException, UNSUPPORTED_C_LIB_EXECPTION_STRING.format(mock_target.default_lib)): + with self.assertRaisesRegexp(NotSupportedException, UNSUPPORTED_C_LIB_EXCEPTION_STRING.format(mock_target.default_lib)): IAR(mock_target) diff --git a/tools/toolchains/arm.py b/tools/toolchains/arm.py index b0bdf682ae0..3a7a8927f14 100644 --- a/tools/toolchains/arm.py +++ b/tools/toolchains/arm.py @@ -39,7 +39,7 @@ UARM_TOOLCHAIN_WARNING = ( "Warning: We noticed that you are using uARM Toolchain. " - "We are deprecating the uARM Toolchain. " + "We are deprecating the use of uARM Toolchain. " "For more information on how to use the ARM toolchain with small C libraries, " "please visit https://os.mbed.com/docs/mbed-os/latest/reference/using-small-c-libraries.html" ) @@ -79,7 +79,10 @@ def __init__(self, target, notify=None, macros=None, self.check_c_lib_supported(target, "arm") - if getattr(target, "default_toolchain", "ARM") == "uARM" or getattr(target, "default_lib", "std") == "small": + if ( + getattr(target, "default_toolchain", "ARM") == "uARM" + or getattr(target, "default_lib", "std") == "small" + ): if "-DMBED_RTOS_SINGLE_THREAD" not in self.flags['common']: self.flags['common'].append("-DMBED_RTOS_SINGLE_THREAD") if "-D__MICROLIB" not in self.flags['common']: @@ -566,7 +569,10 @@ def __init__(self, target, *args, **kwargs): self.check_c_lib_supported(target, "arm") - if getattr(target, "default_toolchain", "ARMC6") == "uARM" or getattr(target, "default_lib", "std") == "small": + if ( + getattr(target, "default_toolchain", "ARMC6") == "uARM" + or getattr(target, "default_lib", "std") == "small" + ): if "-DMBED_RTOS_SINGLE_THREAD" not in self.flags['common']: self.flags['common'].append("-DMBED_RTOS_SINGLE_THREAD") if "-D__MICROLIB" not in self.flags['common']: diff --git a/tools/toolchains/gcc.py b/tools/toolchains/gcc.py index c205f05896a..d4f35f09a67 100644 --- a/tools/toolchains/gcc.py +++ b/tools/toolchains/gcc.py @@ -48,7 +48,7 @@ def __init__(self, target, notify=None, macros=None, build_profile=None, tool_path = TOOLCHAIN_PATHS['GCC_ARM'] # Add flags for current size setting - default_lib = "" + default_lib = "std" if hasattr(target, "default_lib"): self.check_c_lib_supported(target, "gcc_arm") default_lib = target.default_lib diff --git a/tools/toolchains/mbed_toolchain.py b/tools/toolchains/mbed_toolchain.py index d99b07c755b..12d6f976695 100755 --- a/tools/toolchains/mbed_toolchain.py +++ b/tools/toolchains/mbed_toolchain.py @@ -109,7 +109,7 @@ "__MBED_CMSIS_RTOS_CM", "__DSP_PRESENT=1U"], } -UNSUPPORTED_C_LIB_EXECPTION_STRING = "{} C library option not supported for this target." +UNSUPPORTED_C_LIB_EXCEPTION_STRING = "{} C library option not supported for this target." class mbedToolchain(with_metaclass(ABCMeta, object)): OFFICIALLY_SUPPORTED = False @@ -1104,7 +1104,7 @@ def check_c_lib_supported(self, target, toolchain): Check and raise an exception if the requested C library is not supported, target.default_lib is modified to have the lowercased string of its original string. - This is done to be case insensitvie when validating. + This is done to be case insensitive when validating. """ if hasattr(target, "default_lib"): target.default_lib = target.default_lib.lower() @@ -1114,7 +1114,7 @@ def check_c_lib_supported(self, target, toolchain): or target.default_lib not in target.supported_c_libs[toolchain] ): raise NotSupportedException( - UNSUPPORTED_C_LIB_EXECPTION_STRING.format(target.default_lib) + UNSUPPORTED_C_LIB_EXCEPTION_STRING.format(target.default_lib) ) @staticmethod From 3697815761537b317b8f8b0926f77abb8d2a792d Mon Sep 17 00:00:00 2001 From: Rajkumar Kanagaraj Date: Mon, 23 Dec 2019 08:27:13 -0800 Subject: [PATCH 3/4] Minimal-printf: Fix system test without using standard library printf --- .../minimal-printf/compliance/main.cpp | 551 ++++++++++-------- 1 file changed, 310 insertions(+), 241 deletions(-) diff --git a/TESTS/mbed_platform/minimal-printf/compliance/main.cpp b/TESTS/mbed_platform/minimal-printf/compliance/main.cpp index 5660e7c1d8d..a9beda9fec1 100644 --- a/TESTS/mbed_platform/minimal-printf/compliance/main.cpp +++ b/TESTS/mbed_platform/minimal-printf/compliance/main.cpp @@ -42,6 +42,114 @@ using namespace utest::v1; +#define MAX_STRING_SIZE 100 +// Buffer used by test cases to store a test string +static char expected_string[MAX_STRING_SIZE]; + +#define BASE_10 10 +#define BASE_16 16 + +/** This function converts an integer into a string representing the integer in base 10 or base 16. + * + * @param value to be converted to a string. + * @param str is an array where to store the resulting null-terminated string. + * @param base used to represent the string. + * + * @return + * A pointer to the resulting null-terminated string, same as parameter str. + */ +static char *convert_to_string( + uint64_t value, + char str[], + int base = BASE_10, + bool is_negative = false) +{ + int i = 0; + + if (base != BASE_10 && base != BASE_16) { + MBED_ASSERT(0); + } + + if (value == 0) { + str[0] = '0'; + str[1] = '\0'; + return str; + } + + if (is_negative && ((long long) value < 0)) { + value = -value; + } + // Convert a value to a string stored in reverse order in memory. + while (value) { + int remainder = value % base; + str[i++] = (remainder > 9) ? (remainder - 10) + 'A' : remainder + '0'; + value = value / base; + } + + if (is_negative) { + str[i++] = '-'; + } + + str[i] = '\0'; + + // Reverse the string. + int start = 0; + int end = i - 1; + while (start < end) { + swap(*(str + start), *(str + end)); + start++; + end--; + } + return str; +} + +/** This function is using a global buffer to build the test string 'prefix + data + suffix' and + * returns its length. + * + * @param prefix is a null-terminated string. + * @param value to be converted to a string. + * @param base used to represent the string. + * @param suffix is a null-terminated string. + * @param is_negative is used to represent a positive or negative value + * + * @return + * string length + */ +static int make_test_string( + const char *prefix = nullptr, + long long value = 0, + int base = BASE_10, + const char *suffix = nullptr, + bool is_negative = false +) +{ + char *exp_str = &expected_string[0]; + int str_length = 0; + memset(exp_str, 0, MAX_STRING_SIZE); + if (prefix) { + str_length = strlen(prefix); + MBED_ASSERT(str_length < MAX_STRING_SIZE); + strncpy(exp_str, prefix, str_length); + } + + convert_to_string(value, &exp_str[str_length], base, is_negative); + if (suffix) { + str_length = strlen(exp_str); + MBED_ASSERT(strlen(suffix) < (MAX_STRING_SIZE - str_length)); + strncat(exp_str, suffix, str_length); + } + return strlen(exp_str); +} + +// Extract the prefix string which is all characters until '%'. +static void extract_prefix(const char *fmt, char *prefix) +{ + int i = 0; + while (fmt && prefix && fmt[i] != '%') { + prefix[i] = fmt[i]; + i++; + } +} static control_t test_printf_d(const size_t call_count) { @@ -51,84 +159,78 @@ static control_t test_printf_d(const size_t call_count) /*************************************************************************/ /*************************************************************************/ -#if !defined(__NEWLIB_NANO) - // The format specifier %hhd is not supported by Newlib-Nano result_minimal = mbed_printf("hhd: %hhd\r\n", SCHAR_MIN); result_file = mbed_fprintf(stderr, "hhd: %hhd\r\n", SCHAR_MIN); - result_baseline = printf("hhd: %hhd\r\n", SCHAR_MIN); + result_baseline = make_test_string("hhd: ", SCHAR_MIN, BASE_10, "\r\n", true); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); result_minimal = mbed_printf("hhd: %hhd\r\n", SCHAR_MAX); result_file = mbed_fprintf(stderr, "hhd: %hhd\r\n", SCHAR_MAX); - result_baseline = printf("hhd: %hhd\r\n", SCHAR_MAX); + result_baseline = make_test_string("hhd: ", SCHAR_MAX, BASE_10, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); -#endif result_minimal = mbed_printf("hd: %hd\r\n", SHRT_MIN); result_file = mbed_fprintf(stderr, "hd: %hd\r\n", SHRT_MIN); - result_baseline = printf("hd: %hd\r\n", SHRT_MIN); + result_baseline = make_test_string("hd: ", SHRT_MIN, BASE_10, "\r\n", true); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); result_minimal = mbed_printf("hd: %hd\r\n", SHRT_MAX); result_file = mbed_fprintf(stderr, "hd: %hd\r\n", SHRT_MAX); - result_baseline = printf("hd: %hd\r\n", SHRT_MAX); + result_baseline = make_test_string("hd: ", SHRT_MAX, BASE_10, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); result_minimal = mbed_printf("d: %d\r\n", INT_MIN); result_file = mbed_fprintf(stderr, "d: %d\r\n", INT_MIN); - result_baseline = printf("d: %d\r\n", INT_MIN); + result_baseline = make_test_string("d: ", INT_MIN, BASE_10, "\r\n", true); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); result_minimal = mbed_printf("d: %d\r\n", INT_MAX); result_file = mbed_fprintf(stderr, "d: %d\r\n", INT_MAX); - result_baseline = printf("d: %d\r\n", INT_MAX); + result_baseline = make_test_string("d: ", INT_MAX, BASE_10, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); result_minimal = mbed_printf("ld: %ld\r\n", LONG_MIN); result_file = mbed_fprintf(stderr, "ld: %ld\r\n", LONG_MIN); - result_baseline = printf("ld: %ld\r\n", LONG_MIN); + result_baseline = make_test_string("ld: ", LONG_MIN, BASE_10, "\r\n", true); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); result_minimal = mbed_printf("ld: %ld\r\n", LONG_MAX); result_file = mbed_fprintf(stderr, "ld: %ld\r\n", LONG_MAX); - result_baseline = printf("ld: %ld\r\n", LONG_MAX); + result_baseline = make_test_string("ld: ", LONG_MAX, BASE_10, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); -#if !defined(__NEWLIB_NANO) - // The format specifier %lld is not supported by Newlib-Nano result_minimal = mbed_printf("lld: %lld\r\n", LLONG_MIN); result_file = mbed_fprintf(stderr, "lld: %lld\r\n", LLONG_MIN); - result_baseline = printf("lld: %lld\r\n", LLONG_MIN); + result_baseline = make_test_string("lld: ", LLONG_MIN, BASE_10, "\r\n", true); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); result_minimal = mbed_printf("lld: %lld\r\n", LLONG_MAX); result_file = mbed_fprintf(stderr, "lld: %lld\r\n", LLONG_MAX); - result_baseline = printf("lld: %lld\r\n", LLONG_MAX); + result_baseline = make_test_string("lld: ", LLONG_MAX, BASE_10, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); -#endif #ifdef TARGET_LIKE_MBED printf("%%jd not supported by mbed\r\n"); #else result_minimal = mbed_printf("jd: %jd\r\n", INT32_MIN); result_file = mbed_fprintf(stderr, "jd: %jd\r\n", INT32_MIN); - result_baseline = printf("jd: %jd\r\n", (intmax_t) INT32_MIN); + result_baseline = make_test_string("jd: ", (intmax_t) INT32_MIN, BASE_10, "\r\n", true); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); result_minimal = mbed_printf("jd: %jd\r\n", INT32_MAX); result_file = mbed_fprintf(stderr, "jd: %jd\r\n", INT32_MAX); - result_baseline = printf("jd: %jd\r\n", (intmax_t) INT32_MAX); + result_baseline = make_test_string("jd: ", (intmax_t) INT32_MAX, BASE_10, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); #endif @@ -138,13 +240,13 @@ static control_t test_printf_d(const size_t call_count) #else result_minimal = mbed_printf("zd: %zd\r\n", INT32_MIN); result_file = mbed_fprintf(stderr, "zd: %zd\r\n", INT32_MIN); - result_baseline = printf("zd: %zd\r\n", (ssize_t) INT32_MIN); + result_baseline = make_test_string("zd: ", (ssize_t) INT32_MIN, BASE_10, "\r\n", true); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); result_minimal = mbed_printf("zd: %zd\r\n", INT32_MAX); result_file = mbed_fprintf(stderr, "zd: %zd\r\n", INT32_MAX); - result_baseline = printf("zd: %zd\r\n", (ssize_t) INT32_MAX); + result_baseline = make_test_string("zd: ", (ssize_t) INT32_MAX, BASE_10, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); #endif @@ -154,13 +256,13 @@ static control_t test_printf_d(const size_t call_count) #else result_minimal = mbed_printf("td: %td\r\n", PTRDIFF_MIN); result_file = mbed_fprintf(stderr, "td: %td\r\n", PTRDIFF_MIN); - result_baseline = printf("td: %td\r\n", PTRDIFF_MIN); + result_baseline = make_test_string("td: ", PTRDIFF_MIN, BASE_10, "\r\n", true); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); result_minimal = mbed_printf("td: %td\r\n", PTRDIFF_MAX); result_file = mbed_fprintf(stderr, "td: %td\r\n", PTRDIFF_MAX); - result_baseline = printf("td: %td\r\n", PTRDIFF_MAX); + result_baseline = make_test_string("td: ", PTRDIFF_MAX, BASE_10, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); #endif @@ -176,83 +278,78 @@ static control_t test_printf_u(const size_t call_count) /*************************************************************************/ /*************************************************************************/ -#if !defined(__NEWLIB_NANO) - // The format specifier %hhu is not supported by Newlib-Nano result_minimal = mbed_printf("hhu: %hhu\r\n", 0); result_file = mbed_fprintf(stderr, "hhu: %hhu\r\n", 0); - result_baseline = printf("hhu: %hhu\r\n", 0); + result_baseline = make_test_string("hhu: ", 0, BASE_10, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); result_minimal = mbed_printf("hhu: %hhu\r\n", UCHAR_MAX); result_file = mbed_fprintf(stderr, "hhu: %hhu\r\n", UCHAR_MAX); - result_baseline = printf("hhu: %hhu\r\n", UCHAR_MAX); + result_baseline = make_test_string("hhu: ", UCHAR_MAX, BASE_10, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); -#endif result_minimal = mbed_printf("hu: %hu\r\n", 0); result_file = mbed_fprintf(stderr, "hu: %hu\r\n", 0); - result_baseline = printf("hu: %hu\r\n", 0); + result_baseline = make_test_string("hu: ", 0, BASE_10, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); result_minimal = mbed_printf("hu: %hu\r\n", USHRT_MAX); result_file = mbed_fprintf(stderr, "hu: %hu\r\n", USHRT_MAX); - result_baseline = printf("hu: %hu\r\n", USHRT_MAX); + result_baseline = make_test_string("hu: ", USHRT_MAX, BASE_10, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); result_minimal = mbed_printf("u: %u\r\n", 0); result_file = mbed_fprintf(stderr, "u: %u\r\n", 0); - result_baseline = printf("u: %u\r\n", 0); + result_baseline = make_test_string("u: ", 0, BASE_10, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); result_minimal = mbed_printf("u: %u\r\n", UINT_MAX); result_file = mbed_fprintf(stderr, "u: %u\r\n", UINT_MAX); - result_baseline = printf("u: %u\r\n", UINT_MAX); + result_baseline = make_test_string("u: ", UINT_MAX, BASE_10, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); result_minimal = mbed_printf("lu: %lu\r\n", 0UL); result_file = mbed_fprintf(stderr, "lu: %lu\r\n", 0UL); - result_baseline = printf("lu: %lu\r\n", 0UL); + result_baseline = make_test_string("lu: ", 0UL, BASE_10, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); result_minimal = mbed_printf("lu: %lu\r\n", ULONG_MAX); result_file = mbed_fprintf(stderr, "lu: %lu\r\n", ULONG_MAX); - result_baseline = printf("lu: %lu\r\n", ULONG_MAX); + result_baseline = make_test_string("lu: ", ULONG_MAX, BASE_10, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); -#if !defined(__NEWLIB_NANO) - // The format specifier %llu is not supported by Newlib-Nano + result_minimal = mbed_printf("llu: %llu\r\n", 0ULL); result_file = mbed_fprintf(stderr, "llu: %llu\r\n", 0ULL); - result_baseline = printf("llu: %llu\r\n", 0ULL); + result_baseline = make_test_string("llu: ", 0ULL, BASE_10, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); result_minimal = mbed_printf("llu: %llu\r\n", ULLONG_MAX); result_file = mbed_fprintf(stderr, "llu: %llu\r\n", ULLONG_MAX); - result_baseline = printf("llu: %llu\r\n", ULLONG_MAX); + result_baseline = make_test_string("llu: ", ULLONG_MAX, BASE_10, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); -#endif #ifdef TARGET_LIKE_MBED printf("%%ju not supported by mbed\r\n"); #else result_minimal = mbed_printf("ju: %ju\r\n", (uintmax_t) 0); result_file = mbed_fprintf(stderr, "ju: %ju\r\n", (uintmax_t) 0); - result_baseline = printf("ju: %ju\r\n", (uintmax_t) 0); + result_baseline = make_test_string("ju: ", (uintmax_t) 0, BASE_10, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); result_minimal = mbed_printf("ju: %ju\r\n", UINTMAX_MAX); result_file = mbed_fprintf(stderr, "ju: %ju\r\n", UINTMAX_MAX); - result_baseline = printf("ju: %ju\r\n", UINTMAX_MAX); + result_baseline = make_test_string("ju: ", UINTMAX_MAX, BASE_10, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); #endif @@ -262,13 +359,13 @@ static control_t test_printf_u(const size_t call_count) #else result_minimal = mbed_printf("zu: %zu\r\n", 0); result_file = mbed_fprintf(stderr, "zu: %zu\r\n", 0); - result_baseline = printf("zu: %zu\r\n", 0); + result_baseline = make_test_string("zu: ", 0, BASE_10, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); result_minimal = mbed_printf("zu: %zu\r\n", SIZE_MAX); result_file = mbed_fprintf(stderr, "zu: %zu\r\n", SIZE_MAX); - result_baseline = printf("zu: %zu\r\n", SIZE_MAX); + result_baseline = make_test_string("zu: ", SIZE_MAX, BASE_10, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); #endif @@ -278,13 +375,13 @@ static control_t test_printf_u(const size_t call_count) #else result_minimal = mbed_printf("tu: %tu\r\n", 0); result_file = mbed_fprintf(stderr, "tu: %tu\r\n", 0); - result_baseline = printf("tu: %tu\r\n", 0); + result_baseline = make_test_string("tu: ", 0, BASE_10, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); result_minimal = mbed_printf("tu: %tu\r\n", UINTPTR_MAX); result_file = mbed_fprintf(stderr, "tu: %tu\r\n", UINTPTR_MAX); - result_baseline = printf("tu: %tu\r\n", UINTPTR_MAX); + result_baseline = make_test_string("tu: ", UINTPTR_MAX, BASE_10, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); #endif @@ -300,83 +397,78 @@ static control_t test_printf_x(const size_t call_count) /*************************************************************************/ /*************************************************************************/ -#if !defined(__NEWLIB_NANO) - // The format specifier %hhX is not supported by Newlib-Nano result_minimal = mbed_printf("hhX: %hhX\r\n", 0); result_file = mbed_fprintf(stderr, "hhX: %hhX\r\n", 0); - result_baseline = printf("hhX: %hhX\r\n", 0); + result_baseline = make_test_string("hhX: ", 0, BASE_16, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); result_minimal = mbed_printf("hhX: %hhX\r\n", UCHAR_MAX); result_file = mbed_fprintf(stderr, "hhX: %hhX\r\n", UCHAR_MAX); - result_baseline = printf("hhX: %hhX\r\n", UCHAR_MAX); + result_baseline = make_test_string("hhX: ", UCHAR_MAX, BASE_16, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); -#endif result_minimal = mbed_printf("hX: %hX\r\n", 0); result_file = mbed_fprintf(stderr, "hX: %hX\r\n", 0); - result_baseline = printf("hX: %hX\r\n", 0); + result_baseline = make_test_string("hX: ", 0, BASE_16, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); result_minimal = mbed_printf("hX: %hX\r\n", USHRT_MAX); result_file = mbed_fprintf(stderr, "hX: %hX\r\n", USHRT_MAX); - result_baseline = printf("hX: %hX\r\n", USHRT_MAX); + result_baseline = make_test_string("hX: ", USHRT_MAX, BASE_16, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); result_minimal = mbed_printf("X: %X\r\n", 0); result_file = mbed_fprintf(stderr, "X: %X\r\n", 0); - result_baseline = printf("X: %X\r\n", 0); + result_baseline = make_test_string("X: ", 0, BASE_16, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); result_minimal = mbed_printf("X: %X\r\n", UINT_MAX); result_file = mbed_fprintf(stderr, "X: %X\r\n", UINT_MAX); - result_baseline = printf("X: %X\r\n", UINT_MAX); + result_baseline = make_test_string("X: ", UINT_MAX, BASE_16, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); result_minimal = mbed_printf("lX: %lX\r\n", 0UL); result_file = mbed_fprintf(stderr, "lX: %lX\r\n", 0UL); - result_baseline = printf("lX: %lX\r\n", 0UL); + result_baseline = make_test_string("lX: ", 0UL, BASE_16, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); result_minimal = mbed_printf("lX: %lX\r\n", ULONG_MAX); result_file = mbed_fprintf(stderr, "lX: %lX\r\n", ULONG_MAX); - result_baseline = printf("lX: %lX\r\n", ULONG_MAX); + result_baseline = make_test_string("lX: ", ULONG_MAX, BASE_16, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); -#if !defined(__NEWLIB_NANO) - // The format specifier %llX is not supported by Newlib-Nano + result_minimal = mbed_printf("llX: %llX\r\n", 0ULL); result_file = mbed_fprintf(stderr, "llX: %llX\r\n", 0ULL); - result_baseline = printf("llX: %llX\r\n", 0ULL); + result_baseline = make_test_string("llX: ", 0ULL, BASE_16, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); result_minimal = mbed_printf("llX: %llX\r\n", ULLONG_MAX); result_file = mbed_fprintf(stderr, "llX: %llX\r\n", ULLONG_MAX); - result_baseline = printf("llX: %llX\r\n", ULLONG_MAX); + result_baseline = make_test_string("llX: ", ULLONG_MAX, BASE_16, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); -#endif #ifdef TARGET_LIKE_MBED printf("%%jX not supported by mbed\r\n"); #else result_minimal = mbed_printf("jX: %jX\r\n", (uintmax_t) 0); result_file = mbed_fprintf(stderr, "jX: %jX\r\n", (uintmax_t) 0); - result_baseline = printf("jX: %jX\r\n", (uintmax_t) 0); + result_baseline = make_test_string("jX: ", (uintmax_t) 0, BASE_16, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); result_minimal = mbed_printf("jX: %jX\r\n", UINTMAX_MAX); result_file = mbed_fprintf(stderr, "jX: %jX\r\n", UINTMAX_MAX); - result_baseline = printf("jX: %jX\r\n", UINTMAX_MAX); + result_baseline = make_test_string("jX: ", UINTMAX_MAX, BASE_16, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); #endif @@ -386,13 +478,13 @@ static control_t test_printf_x(const size_t call_count) #else result_minimal = mbed_printf("zX: %zX\r\n", 0); result_file = mbed_fprintf(stderr, "zX: %zX\r\n", 0); - result_baseline = printf("zX: %zX\r\n", 0); + result_baseline = make_test_string("zX: ", 0, BASE_16, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); result_minimal = mbed_printf("zX: %zX\r\n", SIZE_MAX); result_file = mbed_fprintf(stderr, "zX: %zX\r\n", SIZE_MAX); - result_baseline = printf("zX: %zX\r\n", SIZE_MAX); + result_baseline = make_test_string("zX: ", SIZE_MAX, BASE_16, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); #endif @@ -402,19 +494,19 @@ static control_t test_printf_x(const size_t call_count) #else result_minimal = mbed_printf("tX: %tX\r\n", 0); result_file = mbed_fprintf(stderr, "tX: %tX\r\n", 0); - result_baseline = printf("tX: %tX\r\n", 0); + result_baseline = make_test_string("tX: ", 0, BASE_16, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); result_minimal = mbed_printf("tX: %tX\r\n", UINTPTR_MAX); result_file = mbed_fprintf(stderr, "tX: %tX\r\n", UINTPTR_MAX); - result_baseline = printf("tX: %tX\r\n", UINTPTR_MAX); + result_baseline = make_test_string("tX: ", UINTPTR_MAX, BASE_16, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); #endif result_minimal = mbed_printf("x: %x\r\n", 11259375); - result_baseline = printf("x: %x\r\n", 11259375); + result_baseline = make_test_string("x: ", 11259375, BASE_16, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); return CaseNext; @@ -425,10 +517,11 @@ static control_t test_printf_percent(const size_t call_count) int result_baseline; int result_minimal; int result_file; + char buffer_baseline[100] = {0}; result_minimal = mbed_printf("%% \r\n"); result_file = mbed_fprintf(stderr, "%% \r\n"); - result_baseline = printf("%% \r\n"); + result_baseline = sprintf(buffer_baseline, "%% \r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_file); @@ -443,80 +536,73 @@ static control_t test_printf_percent(const size_t call_count) static control_t test_snprintf_d(const size_t call_count) { - char buffer_baseline[100]; char buffer_minimal[100]; int result_baseline; int result_minimal; /*************************************************************************/ /*************************************************************************/ -#if !defined(__NEWLIB_NANO) - // The format specifier %hhd is not supported by Newlib-Nano result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hhd: %hhd\r\n", SCHAR_MIN); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hhd: %hhd\r\n", SCHAR_MIN); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("hhd: ", SCHAR_MIN, BASE_10, "\r\n", true); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hhd: %hhd\r\n", SCHAR_MAX); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hhd: %hhd\r\n", SCHAR_MAX); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("hhd: ", SCHAR_MAX, BASE_10, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); -#endif result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hd: %hd\r\n", SHRT_MIN); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hd: %hd\r\n", SHRT_MIN); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("hd: ", SHRT_MIN, BASE_10, "\r\n", true); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hd: %hd\r\n", SHRT_MAX); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hd: %hd\r\n", SHRT_MAX); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("hd: ", SHRT_MAX, BASE_10, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "d: %d\r\n", INT_MIN); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "d: %d\r\n", INT_MIN); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("d: ", INT_MIN, BASE_10, "\r\n", true); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "d: %d\r\n", INT_MAX); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "d: %d\r\n", INT_MAX); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("d: ", INT_MAX, BASE_10, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "ld: %ld\r\n", LONG_MIN); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "ld: %ld\r\n", LONG_MIN); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("ld: ", LONG_MIN, BASE_10, "\r\n", true); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "ld: %ld\r\n", LONG_MAX); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "ld: %ld\r\n", LONG_MAX); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("ld: ", LONG_MAX, BASE_10, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); -#if !defined(__NEWLIB_NANO) - // The format specifier %lld is not supported by Newlib-Nano result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "lld: %lld\r\n", LLONG_MIN); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "lld: %lld\r\n", LLONG_MIN); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("lld: ", LLONG_MIN, BASE_10, "\r\n", true); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "lld: %lld\r\n", LLONG_MAX); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "lld: %lld\r\n", LLONG_MAX); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("lld: ", LLONG_MAX, BASE_10, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); -#endif #ifdef TARGET_LIKE_MBED printf("%%jd not supported by mbed\r\n"); #else result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "jd: %jd\r\n", (intmax_t) INT32_MIN); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "jd: %jd\r\n", (intmax_t) INT32_MIN); - TEST_ASSERT_EQUAL_STRING("jd: -2147483648\r\n", buffer_minimal); + result_baseline = make_test_string("jd: ", (intmax_t) INT32_MIN, BASE_10, "\r\n", true); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "jd: %jd\r\n", (intmax_t) INT32_MAX); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "jd: %jd\r\n", (intmax_t) INT32_MAX); - TEST_ASSERT_EQUAL_STRING("jd: 2147483647\r\n", buffer_minimal); + result_baseline = make_test_string("jd: ", (intmax_t) INT32_MAX, BASE_10, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); #endif @@ -524,13 +610,13 @@ static control_t test_snprintf_d(const size_t call_count) printf("%%zd not supported by mbed\r\n"); #else result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "zd: %zd\r\n", (ssize_t) INT32_MIN); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "zd: %zd\r\n", (ssize_t) INT32_MIN); - TEST_ASSERT_EQUAL_STRING("zd: -2147483648\r\n", buffer_minimal); + result_baseline = make_test_string("zd: ", (ssize_t) INT32_MIN, BASE_10, "\r\n", true); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "zd: %zd\r\n", (ssize_t) INT32_MAX); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "zd: %zd\r\n", (ssize_t) INT32_MAX); - TEST_ASSERT_EQUAL_STRING("zd: 2147483647\r\n", buffer_minimal); + result_baseline = make_test_string("zd: ", (ssize_t) INT32_MAX, BASE_10, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); #endif @@ -538,13 +624,13 @@ static control_t test_snprintf_d(const size_t call_count) printf("%%td not supported by mbed\r\n"); #else result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "td: %td\r\n", PTRDIFF_MIN); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "td: %td\r\n", PTRDIFF_MIN); - TEST_ASSERT_EQUAL_STRING("td: -2147483648\r\n", buffer_minimal); + result_baseline = make_test_string("td: ", PTRDIFF_MIN, BASE_10, "\r\n", true); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "td: %td\r\n", PTRDIFF_MAX); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "td: %td\r\n", PTRDIFF_MAX); - TEST_ASSERT_EQUAL_STRING("td: 2147483647\r\n", buffer_minimal); + result_baseline = make_test_string("td: ", PTRDIFF_MAX, BASE_10, "\r\n", true); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); #endif @@ -553,79 +639,73 @@ static control_t test_snprintf_d(const size_t call_count) static control_t test_snprintf_u(const size_t call_count) { - char buffer_baseline[100]; char buffer_minimal[100]; int result_baseline; int result_minimal; /*************************************************************************/ /*************************************************************************/ -#if !defined(__NEWLIB_NANO) - // The format specifier %hhu is not supported by Newlib-Nano result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hhu: %hhu\r\n", 0); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hhu: %hhu\r\n", 0); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("hhu: ", 0, BASE_10, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hhu: %hhu\r\n", UCHAR_MAX); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hhu: %hhu\r\n", UCHAR_MAX); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("hhu: ", UCHAR_MAX, BASE_10, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); -#endif result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hu: %hu\r\n", 0); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hu: %hu\r\n", 0); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("hu: ", 0, BASE_10, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hu: %hu\r\n", USHRT_MAX); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hu: %hu\r\n", USHRT_MAX); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("hu: ", USHRT_MAX, BASE_10, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "u: %u\r\n", 0); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "u: %u\r\n", 0); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("u: ", 0, BASE_10, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "u: %u\r\n", UINT_MAX); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "u: %u\r\n", UINT_MAX); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("u: ", UINT_MAX, BASE_10, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "lu: %lu\r\n", 0UL); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "lu: %lu\r\n", 0UL); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("lu: ", 0UL, BASE_10, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "lu: %lu\r\n", ULONG_MAX); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "lu: %lu\r\n", ULONG_MAX); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("lu: ", ULONG_MAX, BASE_10, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); -#if !defined(__NEWLIB_NANO) - // The format specifier %llu is not supported by Newlib-Nano + result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "llu: %llu\r\n", 0ULL); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "llu: %llu\r\n", 0ULL); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("llu: ", 0ULL, BASE_10, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "llu: %llu\r\n", ULLONG_MAX); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "llu: %llu\r\n", ULLONG_MAX); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("llu: ", ULLONG_MAX, BASE_10, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); -#endif #ifdef TARGET_LIKE_MBED printf("%%ju not supported by mbed\r\n"); #else result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "ju: %ju\r\n", (uintmax_t) 0); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "ju: %ju\r\n", (uintmax_t) 0); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("ju: ", (uintmax_t) 0, BASE_10, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "ju: %ju\r\n", UINTMAX_MAX); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "ju: %ju\r\n", UINTMAX_MAX); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("ju: ", UINTMAX_MAX, BASE_10, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); #endif @@ -633,13 +713,13 @@ static control_t test_snprintf_u(const size_t call_count) printf("%%zu not supported by mbed\r\n"); #else result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "zu: %zu\r\n", 0); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "zu: %zu\r\n", 0); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("zu: ", 0, BASE_10, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "zu: %zu\r\n", SIZE_MAX); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "zu: %zu\r\n", SIZE_MAX); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("zu: ", SIZE_MAX, BASE_10, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); #endif @@ -647,13 +727,13 @@ static control_t test_snprintf_u(const size_t call_count) printf("%%tu not supported by mbed\r\n"); #else result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "tu: %tu\r\n", 0); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "tu: %tu\r\n", 0); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("tu: ", 0, BASE_10, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "tu: %tu\r\n", UINTPTR_MAX); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "tu: %tu\r\n", UINTPTR_MAX); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("tu: ", UINTPTR_MAX, BASE_10, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); #endif @@ -662,78 +742,72 @@ static control_t test_snprintf_u(const size_t call_count) static control_t test_snprintf_x(const size_t call_count) { - char buffer_baseline[100]; char buffer_minimal[100]; int result_baseline; int result_minimal; /*************************************************************************/ /*************************************************************************/ -#if !defined(__NEWLIB_NANO) - // The format specifier %hhX is not supported by Newlib-Nano result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hhX: %hhX\r\n", 0); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hhX: %hhX\r\n", 0); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("hhX: ", 0, BASE_16, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hhX: %hhX\r\n", UCHAR_MAX); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hhX: %hhX\r\n", UCHAR_MAX); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("hhX: ", UCHAR_MAX, BASE_16, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); -#endif result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hX: %hX\r\n", 0); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hX: %hX\r\n", 0); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("hX: ", 0, BASE_16, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hX: %hX\r\n", USHRT_MAX); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hX: %hX\r\n", USHRT_MAX); + result_baseline = make_test_string("hX: ", USHRT_MAX, BASE_16, "\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "X: %X\r\n", 0); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "X: %X\r\n", 0); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("X: ", 0, BASE_16, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "X: %X\r\n", UINT_MAX); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "X: %X\r\n", UINT_MAX); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("X: ", UINT_MAX, BASE_16, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "lX: %lX\r\n", 0UL); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "lX: %lX\r\n", 0UL); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("lX: ", 0UL, BASE_16, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "lX: %lX\r\n", ULONG_MAX); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "lX: %lX\r\n", ULONG_MAX); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("lX: ", ULONG_MAX, BASE_16, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); -#if !defined(__NEWLIB_NANO) - // The format specifier %llX is not supported by Newlib-Nano + result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "llX: %llX\r\n", 0ULL); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "llX: %llX\r\n", 0ULL); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("llX: ", 0ULL, BASE_16, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "llX: %llX\r\n", ULLONG_MAX); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "llX: %llX\r\n", ULLONG_MAX); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("llX: ", ULLONG_MAX, BASE_16, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); -#endif #ifdef TARGET_LIKE_MBED printf("%%jX not supported by mbed\r\n"); #else result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "jX: %jX\r\n", (uintmax_t) 0); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "jX: %jX\r\n", (uintmax_t) 0); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("jX: ", (uintmax_t) 0, BASE_16, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "jX: %jX\r\n", UINTMAX_MAX); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "jX: %jX\r\n", UINTMAX_MAX); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("jX: ", UINTMAX_MAX, BASE_16, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); #endif @@ -741,13 +815,13 @@ static control_t test_snprintf_x(const size_t call_count) printf("%%xX not supported by mbed\r\n"); #else result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "zX: %zX\r\n", 0); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "zX: %zX\r\n", 0); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("zX: ", 0, BASE_16, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "zX: %zX\r\n", SIZE_MAX); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "zX: %zX\r\n", SIZE_MAX); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("zX: ", SIZE_MAX, BASE_16, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); #endif @@ -755,13 +829,13 @@ static control_t test_snprintf_x(const size_t call_count) printf("%%tX not supported by mbed\r\n"); #else result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "tX: %tX\r\n", 0); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "tX: %tX\r\n", 0); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("tX: ", 0, BASE_16, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "tX: %tX\r\n", UINTPTR_MAX); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "tX: %tX\r\n", UINTPTR_MAX); - TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); + result_baseline = make_test_string("tX: ", UINTPTR_MAX, BASE_16, "\r\n"); + TEST_ASSERT_EQUAL_STRING(expected_string, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); #endif @@ -776,7 +850,7 @@ static control_t test_snprintf_percent(const size_t call_count) int result_minimal; result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "%% \r\n"); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "%% \r\n"); + result_baseline = sprintf(buffer_baseline, "%% \r\n"); TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); @@ -799,35 +873,41 @@ static control_t test_snprintf_unsupported_specifier(const size_t call_count) #if MBED_CONF_PLATFORM_MINIMAL_PRINTF_ENABLE_FLOATING_POINT static control_t test_printf_f(const size_t call_count) { + char buffer_baseline[100]; int result_baseline; int result_minimal; - +#define CLEAN_BUFFER memset(buffer_baseline, 0x00, sizeof(buffer_baseline)) /*************************************************************************/ /*************************************************************************/ - double pi = 3.14159265359; - - + CLEAN_BUFFER; result_minimal = mbed_printf("f: %f\r\n", 3.0089); - result_baseline = printf("f: %f\r\n", 3.0089); + result_baseline = sprintf(buffer_baseline, "f: 3.008900\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); - + CLEAN_BUFFER; result_minimal = mbed_printf("f: %f\r\n", 7.0); - result_baseline = printf("f: %f\r\n", 7.0); + result_baseline = sprintf(buffer_baseline, "f: 7.000000\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); - + CLEAN_BUFFER; result_minimal = mbed_printf("f: %f\r\n", -1 * pi); - result_baseline = printf("f: %f\r\n", -1 * pi); + result_baseline = sprintf(buffer_baseline, "f: -3.141593\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); - + CLEAN_BUFFER; result_minimal = mbed_printf("f: %f\r\n", 0.0); - result_baseline = printf("f: %f\r\n", 0.0); + result_baseline = sprintf(buffer_baseline, "f: 0.000000\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); - + CLEAN_BUFFER; result_minimal = mbed_printf("f: %f\r\n", pi); - result_baseline = printf("f: %f\r\n", pi); + result_baseline = sprintf(buffer_baseline, "f: 3.141593\r\n"); + TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); + CLEAN_BUFFER; + result_minimal = mbed_printf("f: %f\r\n", 2.12345651); + result_baseline = sprintf(buffer_baseline, "f: 2.123457\r\n"); + TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); + CLEAN_BUFFER; + result_minimal = mbed_printf("f: %f\r\n", 2.12345649); + result_baseline = sprintf(buffer_baseline, "f: 2.123456\r\n"); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); - return CaseNext; } @@ -837,34 +917,34 @@ static control_t test_snprintf_f(const size_t call_count) char buffer_minimal[100]; int result_baseline; int result_minimal; - +#define CLEAN_BUFFER memset(buffer_baseline, 0x00, sizeof(buffer_baseline)) /*************************************************************************/ /*************************************************************************/ double pi = 3.14159265359; - + CLEAN_BUFFER; result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "f: %f\r\n", 3.0089); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "f: %f\r\n", 3.0089); + result_baseline = sprintf(buffer_baseline, "f: 3.008900\r\n"); TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); - + CLEAN_BUFFER; result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "f: %f\r\n", 7.0); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "f: %f\r\n", 7.0); + result_baseline = sprintf(buffer_baseline, "f: 7.000000\r\n"); TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); - + CLEAN_BUFFER; result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "f: %f\r\n", -1 * pi); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "f: %f\r\n", -1 * pi); + result_baseline = sprintf(buffer_baseline, "f: -3.141593\r\n"); TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); - + CLEAN_BUFFER; result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "f: %f\r\n", 0.0); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "f: %f\r\n", 0.0); + result_baseline = sprintf(buffer_baseline, "f: 0.000000\r\n"); TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); - + CLEAN_BUFFER; result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "f: %f\r\n", pi); - result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "f: %f\r\n", pi); + result_baseline = sprintf(buffer_baseline, "f: 3.141593\r\n"); TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); @@ -877,44 +957,45 @@ static control_t test_snprintf_f(const size_t call_count) * Template parameters: * 'T' is the type being tested * 'buf_size' is the buffer size used in tests + * 'base' is used to represent data in BASE_10 or BASE_16 numeral system * Function parameters: * 'fmt' is the format to use for sprintf * 'data' is the data that will be printed + * 'is_negative' is true for negative number, false for positive number */ -template -static control_t test_snprintf_buffer_overflow_generic(const char *fmt, T data) +template +static control_t test_snprintf_buffer_overflow_generic(const char *fmt, T data, bool is_negative = false) { char buffer_baseline[buf_size]; char buffer_minimal[buf_size]; int result_baseline; int result_minimal; -#if !defined(__MICROLIB) - // Microlib snprintf always returns zero if the size - // to copy from the buffer is zero. - // See reported microlib bug SDCOMP-54710 + char prefix[buf_size] = { 0 }; + // fmt string has "format specifier: %format specifier" + // Extract the string preceding the first '%' from fmt. + extract_prefix(fmt, &prefix[0]); + result_baseline = make_test_string(prefix, data, base, nullptr, is_negative); /* empty buffer test */ result_minimal = mbed_snprintf(buffer_minimal, 0, fmt, data); - result_baseline = snprintf(buffer_baseline, 0, fmt, data); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); -#endif /* buffer isn't large enough, output needs to be truncated */ result_minimal = mbed_snprintf(buffer_minimal, buf_size - 2, fmt, data); - result_baseline = snprintf(buffer_baseline, buf_size - 2, fmt, data); + snprintf(buffer_baseline, buf_size - 2, "%s", expected_string); TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); /* buffer is one byte shorter than needed, string terminator must be written and output must be truncated */ result_minimal = mbed_snprintf(buffer_minimal, buf_size - 1, fmt, data); - result_baseline = snprintf(buffer_baseline, buf_size - 1, fmt, data); + snprintf(buffer_baseline, buf_size - 1, "%s", expected_string); TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); /* buffer is just long enough */ result_minimal = mbed_snprintf(buffer_minimal, buf_size, fmt, data); - result_baseline = snprintf(buffer_baseline, buf_size, fmt, data); + snprintf(buffer_baseline, buf_size, "%s", expected_string); TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); @@ -926,21 +1007,18 @@ static control_t test_snprintf_buffer_overflow_generic(const char *fmt, T data) be large enough to fit the printed data. */ static control_t test_snprintf_buffer_overflow_d(const size_t call_count) { - return test_snprintf_buffer_overflow_generic("d: %d", -1024); + return test_snprintf_buffer_overflow_generic("d: %d", -1024, true); } static control_t test_snprintf_buffer_overflow_ld(const size_t call_count) { - return test_snprintf_buffer_overflow_generic("ld: %ld", -1048576L); + return test_snprintf_buffer_overflow_generic("ld: %ld", -1048576L, true); } -#if !defined(__NEWLIB_NANO) -// The format specifier %lld is not supported by Newlib-Nano static control_t test_snprintf_buffer_overflow_lld(const size_t call_count) { - return test_snprintf_buffer_overflow_generic("lld: %lld", -1099511627776LL); + return test_snprintf_buffer_overflow_generic("lld: %lld", -1099511627776LL, true); } -#endif static control_t test_snprintf_buffer_overflow_u(const size_t call_count) { @@ -952,31 +1030,25 @@ static control_t test_snprintf_buffer_overflow_lu(const size_t call_count) return test_snprintf_buffer_overflow_generic("lu: %lu", 1048576UL); } -#if !defined(__NEWLIB_NANO) -// The format specifier %llu is not supported by Newlib-Nano static control_t test_snprintf_buffer_overflow_llu(const size_t call_count) { return test_snprintf_buffer_overflow_generic("llu: %llu", 1099511627776ULL); } -#endif static control_t test_snprintf_buffer_overflow_x(const size_t call_count) { - return test_snprintf_buffer_overflow_generic("x: 0x%x", 0x400); + return test_snprintf_buffer_overflow_generic("x: 0x%x", 0x400); } static control_t test_snprintf_buffer_overflow_lx(const size_t call_count) { - return test_snprintf_buffer_overflow_generic("lx: 0x%lx", 0x100000UL); + return test_snprintf_buffer_overflow_generic("lx: 0x%lx", 0x100000UL); } -#if !defined(__NEWLIB_NANO) -// The format specifier %llx is not supported by Newlib-Nano static control_t test_snprintf_buffer_overflow_llx(const size_t call_count) { - return test_snprintf_buffer_overflow_generic("llx: 0x%llx", 0x10000000000ULL); + return test_snprintf_buffer_overflow_generic("llx: 0x%llx", 0x10000000000ULL); } -#endif utest::v1::status_t greentea_setup(const size_t number_of_cases) { @@ -1000,16 +1072,13 @@ Case cases[] = { #endif Case("snprintf buffer overflow %d", test_snprintf_buffer_overflow_d), Case("snprintf buffer overflow %ld", test_snprintf_buffer_overflow_ld), + Case("snprintf buffer overflow %lld", test_snprintf_buffer_overflow_lld), Case("snprintf buffer overflow %u", test_snprintf_buffer_overflow_u), Case("snprintf buffer overflow %lu", test_snprintf_buffer_overflow_lu), + Case("snprintf buffer overflow %llu", test_snprintf_buffer_overflow_llu), Case("snprintf buffer overflow %x", test_snprintf_buffer_overflow_x), Case("snprintf buffer overflow %lx", test_snprintf_buffer_overflow_lx), -#if !defined(__NEWLIB_NANO) - // The format specifiers %lld,%llu,%llx are not supported by Newlib-Nano - Case("snprintf buffer overflow %lld", test_snprintf_buffer_overflow_lld), - Case("snprintf buffer overflow %llu", test_snprintf_buffer_overflow_llu), Case("snprintf buffer overflow %llx", test_snprintf_buffer_overflow_llx), -#endif }; Specification specification(greentea_setup, cases, greentea_test_teardown_handler); From 6a8c43252bfb785132e91253e1dba464020ee614 Mon Sep 17 00:00:00 2001 From: Rajkumar Kanagaraj Date: Thu, 2 Jan 2020 02:46:21 -0800 Subject: [PATCH 4/4] Fix the CI build issue --- .../source/TARGET_CORTEX/TOOLCHAIN_ARM_STD/mbed_boot_arm_std.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/rtos/source/TARGET_CORTEX/TOOLCHAIN_ARM_STD/mbed_boot_arm_std.c b/rtos/source/TARGET_CORTEX/TOOLCHAIN_ARM_STD/mbed_boot_arm_std.c index d7b909b6a26..9bafcef5a2f 100644 --- a/rtos/source/TARGET_CORTEX/TOOLCHAIN_ARM_STD/mbed_boot_arm_std.c +++ b/rtos/source/TARGET_CORTEX/TOOLCHAIN_ARM_STD/mbed_boot_arm_std.c @@ -16,13 +16,14 @@ */ #include #include +#include "cmsis.h" #include "mbed_boot.h" extern uint32_t Image$$ARM_LIB_STACK$$ZI$$Base[]; extern uint32_t Image$$ARM_LIB_STACK$$ZI$$Length[]; #if !defined(__MICROLIB) -#include "cmsis.h" + #include "mbed_critical.h" #include #include "mbed_rtos_storage.h"