Keil Logo Arm Logo

Technical Support

On-Line Manuals

Libraries and Floating Point Support Guide

Conventions and feedback The ARM C and C++ libraries Mandatory linkage with the C library C and C++ runtime libraries C and C++ library features Library heap usage requirements of the ARM C and C Compliance with the Application Binary Interface ( Increasing portability of object files to other CL ARM C and C++ library directory structure Selection of ARM C and C++ library variants based Thumb C libraries C++ and C libraries and the std namespace ARM C libraries and multithreading ARM C libraries and reentrant functions ARM C libraries and thread-safe functions Use of static data in the C libraries Use of the __user_libspace static data area by the C library functions to access subsections of the _ Re-implementation of legacy function __user_libspa Management of locks in multithreaded applications How to ensure re-implemented mutex functions are c Using the ARM C library in a multithreaded environ Thread safety in the ARM C library Thread safety in the ARM C++ library The floating-point status word in a multithreaded Using the C library with an application Using the C and C++ libraries with an application Using $Sub$$ to mix semihosted and nonsemihosted I Using the libraries in a nonsemihosting environmen C++ exceptions in a non-semihosting environment Direct semihosting C library function dependencies Indirect semihosting C library function dependenci C library API definitions for targeting a differen Building an application without the C library Creating an application as bare machine C without Integer and floating-point compiler functions and Bare machine integer C Bare machine C with floating-point processing Customized C library startup code and access to C Program design when exploiting the C library Using low-level functions when exploiting the C li Using high-level functions when exploiting the C l Using malloc() when exploiting the C library Tailoring the C library to a new execution environ How C and C++ programs use the library functions Initialization of the execution environment and ex C++ initialization, construction and destruction Legacy support for C$$pi_ctorvec instead of .init_ Exceptions system initialization Emergency buffer memory for exceptions Library functions called from main() Program exit and the assert macro Assembler macros that tailor locale functions in t Link time selection of the locale subsystem in the ISO8859-1 implementation Shift-JIS and UTF-8 implementation Runtime selection of the locale subsystem in the C Definition of locale data blocks in the C library LC_CTYPE data block LC_COLLATE data block LC_MONETARY data block LC_NUMERIC data block LC_TIME data block Modification of C library functions for error sign Modification of memory management functions in the Avoiding the heap and heap-using library functions C library support for memory allocation functions Heap1, standard heap implementation Heap2, alternative heap implementation Using a heap implementation from bare machine C Stack pointer initialization and heap bounds Defining __initial_sp, __heap_base and __heap_limi Extending heap size at runtime Legacy support for __user_initial_stackheap() Tailoring input/output functions in the C and C++ Target dependencies on low-level functions in the The C library printf family of functions The C library scanf family of functions Redefining low-level library functions to enable d The C library functions fread(), fgets() and gets( Re-implementing __backspace() in the C library Re-implementing __backspacewc() in the C library Redefining target-dependent system I/O functions i Tailoring non-input/output C library functions Real-time integer division in the ARM libraries Selecting real-time division in the ARM libraries How the ARM C library fulfills ISO C specification mathlib error handling ISO-compliant implementation of signals supported ISO-compliant C library input/output characteristi Standard C++ library implementation definition C library functions and extensions Persistence of C and C++ library names across rele Link time selection of C and C++ libraries Managing projects that have explicit C or C++ libr Compiler generated and library-resident helper fun C and C++ library naming conventions Using macro__ARM_WCHAR_NO_IO to disable FILE decla The ARM C micro-library Floating-point support

Libraries and Floating Point Support Guide

Thread safety in the ARM C++ library

Thread safety in the ARM C++ library

The following points summarize thread safety in the C++ library:

  • The function std::set_new_handler() is not thread-safe. This means that some forms of ::operator new and ::operator delete are not thread-safe with respect to std::set_new_handler():

    • The default C++ runtime library implementations of the following use malloc() and free() and are thread-safe with respect to each other. They are not thread-safe with respect to std::set_new_handler(). You are permitted to replace them:

      ::operator new(std::size_t)

      ::operator new[](std::size_t)

      ::operator new(std::size_t, const std::nothrow_t&)

      ::operator new[](std::size_t, const std::nothrow_t)

      ::operator delete(void*)

      ::operator delete[](void*)

      ::operator delete(void*, const std::nothrow_t&)

      ::operator delete[](void*, const std::nothrow_t&)

    • The following placement forms are also thread-safe. You are not permitted to replace them:

      ::operator new(std::size_t, void*)

      ::operator new[](std::size_t, void*)

      ::operator delete(void*, void*)

      ::operator delete[](void*, void*)

  • Construction and destruction of global objects are not thread-safe.

  • Construction of local static objects can be made thread-safe if you re-implement the functions __cxa_guard_acquire(), __cxa_guard_release(), __cxa_guard_abort(), __cxa_atexit() and __aeabi_atexit() appropriately. For example, with appropriate re-implementation, the following construction of lsobj can be made thread-safe:

    struct T { T(); };
    void f() { static T lsobj; }
    
  • Throwing an exception is thread-safe if any user constructors and destructors that get called are also thread-safe.

  • The ARM C++ library uses the ARM C library. To use the ARM C++ library in a multithreaded environment, you must provide the same functions that you would be required to provide when using the ARM C library in a multithreaded environment.

Show/hideRogue Wave Standard C++ library

The Rogue Wave Standard C++ library is a part of the ARM C++ library. What applies to the ARM C++ library applies to the Rogue Wave Standard C++ library too. In the Rogue Wave Standard C++ library, specifically:

  • all containers and all functions are reentrant, making no use of internal, modifiable static data

    • except for the std::random_shuffle function, which uses static data to record the random number

  • The iostream and locale classes are not thread safe.

You must protect shared objects while using the iostream and locale classes, and the std::random_shuffle function. To do this, you might use mutex functions, or co-operative threading. As an example, in a typical case of a pre-emptive multitasking environment, one that uses mutex functions with containers, this means that:

  • reader threads can safely share a container if no thread writes to it during the reads

  • while a thread writes to a shared container, you must apply locking around the use of the container

  • writer threads can write to different containers safely

  • you must apply locking around the use of random_shuffle

  • multiple threads cannot use iostream and locale classes safely unless you apply locking around the use of their objects.

Copyright © 2007-2008, 2011-2012 ARM. All rights reserved.ARM DUI 0378D
Non-ConfidentialID062912

Keil logo

Arm logo
Important information

This site uses cookies to store information on your computer. By continuing to use our site, you consent to our cookies.