ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #12068 from rajkan01/feature_bare_metal 

Enabling small C library option and deprecating uARM toolchain
pull/12055/head
Martin Kojtal 2020-01-03 11:35:48 +00:00 committed by GitHub
parent 4feca5942a 6a8c43252b
commit fc2a71064d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
44 changed files with 895 additions and 292 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
TESTS/configs/baremetal.json
View File

@ -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"
}
}
}

6
TESTS/mbed_drivers/c_strings/main.cpp
View File

@ -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)

495
TESTS/mbed_platform/minimal-printf/compliance/main.cpp
View File

File diff suppressed because it is too large Load Diff

8
platform/source/mbed_retarget.cpp
View File

@ -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

5
rtos/source/TARGET_CORTEX/TOOLCHAIN_ARM_MICRO/mbed_boot_arm_micro.c
View File

@ -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);
}

55
rtos/source/TARGET_CORTEX/TOOLCHAIN_ARM_STD/mbed_boot_arm_std.c
View File

@ -16,10 +16,15 @@
*/
#include <stdlib.h>
#include <string.h>
#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 <rt_misc.h>
#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 <stdint.h>
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)

28
targets/TARGET_STM/TARGET_STM32F2/TARGET_NUCLEO_F207ZG/device/TOOLCHAIN_ARM_STD/stm32f207xx.sct
View File

@ -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
}
}

29
targets/TARGET_STM/TARGET_STM32F3/TARGET_STM32F303xE/device/TOOLCHAIN_ARM_STD/stm32f303xe.sct
View File

@ -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
; STM32F303RE: 512KB FLASH (0x80000) + 64KB SRAM (0x10000) + 16KB CCMRAM (0x4000)
LR_IROM1 MBED_APP_START MBED_APP_SIZE { ; load region size_region
#define RAM_FIXED_SIZE (MBED_BOOT_STACK_SIZE+VECTOR_SIZE)
ER_IROM1 MBED_APP_START MBED_APP_SIZE { ; load address = execution address
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)
}
; 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) {

43
targets/TARGET_STM/TARGET_STM32F4/TARGET_STM32F411xE/device/TOOLCHAIN_ARM_STD/stm32f411re.sct
View File

@ -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
}
}

40
targets/TARGET_STM/TARGET_STM32F4/TARGET_STM32F429xI/device/TOOLCHAIN_ARM_STD/stm32f429xx.sct
View File

@ -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
}
}

40
targets/TARGET_STM/TARGET_STM32L0/TARGET_NUCLEO_L073RZ/device/TOOLCHAIN_ARM_STD/stm32l073xz.sct
View File

@ -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
; STM32L073RZ: 192KB FLASH (0x30000) + 20KB RAM (0x5000)
LR_IROM1 MBED_APP_START MBED_APP_SIZE { ; load region size_region
#if !defined(MBED_RAM_SIZE)
#define MBED_RAM_SIZE 0x5000
#endif
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
}
}

41
targets/targets.json
View File

@ -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.",
@ -1496,6 +1501,11 @@
"bootloader_supported": true,
"overrides": {
"network-default-interface-type": "ETHERNET"
},
"supported_c_libs": {
"arm": ["std", "small"],
"gcc_arm": ["std", "small"],
"iar": ["std"]
}
},
"SDT64B": {
@ -1783,6 +1793,11 @@
"bootloader_supported": true,
"overrides": {
"network-default-interface-type": "ETHERNET"
},
"supported_c_libs": {
"arm": ["std", "small"],
"gcc_arm": ["std", "small"],
"iar": ["std"]
}
},
"K82F": {
@ -2434,7 +2449,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"],
@ -2572,7 +2592,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"],
@ -2824,6 +2849,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": {
@ -4398,7 +4428,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"],

3
tools/build_api.py
View File

@ -47,6 +47,7 @@ from .targets import TARGET_NAMES, TARGET_MAP, CORE_ARCH, Target
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:

7
tools/test/config/app_override_libs/targets.json
View File

@ -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"]
}
}
}

5
tools/test/config/compound_inheritance/targets.json
View File

@ -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",

10
tools/test/config/double_define/targets.json
View File

@ -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",

7
tools/test/config/feature_compesition/targets.json
View File

@ -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"]
}
}
}

7
tools/test/config/feature_recursive_add/targets.json
View File

@ -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"]
}
}
}

7
tools/test/config/feature_recursive_complex/targets.json
View File

@ -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"]
}
}
}

7
tools/test/config/feature_remove/targets.json
View File

@ -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"]
}
}
}

7
tools/test/config/lib_requires_missing_lib/targets.json
View File

@ -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"]
}
}
}

7
tools/test/config/macro_inheritance/targets.json
View File

@ -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"]
}
}
}

5
tools/test/config/override_labels_libs/targets.json
View File

@ -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": {

5
tools/test/config/override_labels_libs_more/targets.json
View File

@ -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": {

5
tools/test/config/override_labels_targets/targets.json
View File

@ -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",

5
tools/test/config/override_precidence/targets.json
View File

@ -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": {

5
tools/test/config/override_undefined/targets.json
View File

@ -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",

5
tools/test/config/override_undefined_libs/targets.json
View File

@ -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": {

5
tools/test/config/override_with_labels/targets.json
View File

@ -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": {

5
tools/test/config/range_limits/targets.json
View File

@ -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"]
}
}

7
tools/test/config/range_limits_invalid/targets.json
View File

@ -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"]
}
}
}

5
tools/test/config/range_limits_override_invalid/targets.json
View File

@ -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"]
}
}

14
tools/test/config/requires_exclude_in_include/targets.json
View File

@ -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"]
}
}
}

7
tools/test/config/requires_from_lib/targets.json
View File

@ -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"]
}
}
}

14
tools/test/config/requires_include_in_exclude/targets.json
View File

@ -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"]
}
}
}

14
tools/test/config/requires_omit_lib/targets.json
View File

@ -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"]
}
}
}

7
tools/test/config/simple_features/targets.json
View File

@ -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"]
}
}
}

5
tools/test/config/simple_iheritance/targets.json
View File

@ -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",

10
tools/test/targets/target_test.py
View File

@ -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": {
@ -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
}
}

131
tools/test/toolchains/test_toolchains.py
View File

@ -20,7 +20,8 @@ sys.path.insert(0, ROOT)
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 @@ class TestArmToolchain(TestCase):
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 @@ class TestArmToolchain(TestCase):
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 @@ class TestGccToolchain(TestCase):
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 @@ class TestGccToolchain(TestCase):
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)

22
tools/toolchains/arm.py
View File

@ -31,12 +31,18 @@ from tools.resources import FileRef
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 @@ class ARM(mbedToolchain):
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 @@ class ARMC6(ARM_STD):
"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']:

4
tools/toolchains/gcc.py
View File

@ -50,12 +50,14 @@ class GCC(mbedToolchain):
# 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)

3
tools/toolchains/iar.py
View File

@ -22,7 +22,6 @@ from distutils.version import LooseVersion
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 @@ class IAR(mbedToolchain):
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"]

19
tools/toolchains/mbed_toolchain.py
View File

@ -109,6 +109,7 @@ CORTEX_SYMBOLS = {
"__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 @@ class mbedToolchain(with_metaclass(ABCMeta, object)):
):
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():