diff --git a/TESTS/configs/baremetal.json b/TESTS/configs/baremetal.json index bec2fd801b4..9d6963cac65 100644 --- a/TESTS/configs/baremetal.json +++ b/TESTS/configs/baremetal.json @@ -37,6 +37,24 @@ "target_overrides": { "*": { "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 f592851769a..9b79f2bd9ee 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,15 @@ 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) + //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), 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..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) { @@ -53,61 +161,61 @@ static control_t test_printf_d(const size_t call_count) /*************************************************************************/ 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); 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); 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); @@ -116,13 +224,13 @@ static control_t test_printf_d(const size_t call_count) #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 @@ -132,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 @@ -148,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 @@ -172,61 +280,61 @@ static control_t test_printf_u(const size_t call_count) /*************************************************************************/ 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); 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); 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); @@ -235,13 +343,13 @@ static control_t test_printf_u(const size_t call_count) #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 @@ -251,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 @@ -267,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 @@ -291,61 +399,61 @@ static control_t test_printf_x(const size_t call_count) /*************************************************************************/ 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); 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); 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); @@ -354,13 +462,13 @@ static control_t test_printf_x(const size_t call_count) #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 @@ -370,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 @@ -386,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; @@ -409,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); @@ -427,7 +536,6 @@ 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; @@ -435,66 +543,66 @@ static control_t test_snprintf_d(const size_t call_count) /*************************************************************************/ /*************************************************************************/ 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); 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); 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); #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 @@ -502,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 @@ -516,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 @@ -531,7 +639,6 @@ 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; @@ -539,66 +646,66 @@ static control_t test_snprintf_u(const size_t call_count) /*************************************************************************/ /*************************************************************************/ 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); 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); 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); #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 @@ -606,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 @@ -620,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 @@ -635,7 +742,6 @@ 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; @@ -643,65 +749,65 @@ static control_t test_snprintf_x(const size_t call_count) /*************************************************************************/ /*************************************************************************/ 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); 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); 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); #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 @@ -709,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 @@ -723,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 @@ -744,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); @@ -767,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; } @@ -805,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); @@ -845,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); @@ -894,17 +1007,17 @@ 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); } 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); } static control_t test_snprintf_buffer_overflow_u(const size_t call_count) @@ -924,17 +1037,17 @@ static control_t test_snprintf_buffer_overflow_llu(const size_t call_count) 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); } 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); } utest::v1::status_t greentea_setup(const size_t number_of_cases) 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..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,10 +16,15 @@ */ #include #include - #include "cmsis.h" -#include "mbed_critical.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 "mbed_critical.h" #include #include "mbed_rtos_storage.h" #include "cmsis_os2.h" @@ -27,8 +32,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 +255,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..4148fd64990 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": { @@ -2441,7 +2456,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 +2599,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 +2856,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": { @@ -4425,7 +4455,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/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/test_toolchains.py b/tools/test/toolchains/test_toolchains.py index 0a8dca2675e..d7877a74d8b 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_EXCEPTION_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 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_EXCEPTION_STRING.format(mock_target.default_lib)): + ARM_STD(mock_target) + 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 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_EXCEPTION_STRING.format(mock_target.default_lib)): + ARM_STD(mock_target) + mock_target.default_toolchain = "ARMC6" + with self.assertRaisesRegexp(NotSupportedException, UNSUPPORTED_C_LIB_EXCEPTION_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 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_EXCEPTION_STRING.format(mock_target.default_lib)): + GCC_ARM(mock_target) + + def test_gcc_arm_default_lib_small_exception(self): + """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_EXCEPTION_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 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"]} + 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_EXCEPTION_STRING.format(mock_target.default_lib)) + + def test_iar_default_lib_std_exception(self): + """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_EXCEPTION_STRING.format(mock_target.default_lib)): + IAR(mock_target) + + def test_iar_default_lib_small_exception(self): + """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_EXCEPTION_STRING.format(mock_target.default_lib)): + IAR(mock_target) diff --git a/tools/toolchains/arm.py b/tools/toolchains/arm.py index f83bc855054..3a7a8927f14 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 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" +) class ARM(mbedToolchain): LINKER_EXT = '.sct' @@ -71,7 +77,12 @@ 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 +567,12 @@ 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..d4f35f09a67 100644 --- a/tools/toolchains/gcc.py +++ b/tools/toolchains/gcc.py @@ -50,12 +50,14 @@ def __init__(self, target, notify=None, macros=None, build_profile=None, # Add flags for current size setting default_lib = "std" 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..12d6f976695 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_EXCEPTION_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 insensitive 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_EXCEPTION_STRING.format(target.default_lib) + ) + @staticmethod def _overwrite_when_not_equal(filename, content): if not exists(filename) or content != open(filename).read():