mbed_retarget.cpp

00001 /* mbed Microcontroller Library
00002  * Copyright (c) 2006-2015 ARM Limited
00003  *
00004  * Licensed under the Apache License, Version 2.0 (the "License");
00005  * you may not use this file except in compliance with the License.
00006  * You may obtain a copy of the License at
00007  *
00008  *     http://www.apache.org/licenses/LICENSE-2.0
00009  *
00010  * Unless required by applicable law or agreed to in writing, software
00011  * distributed under the License is distributed on an "AS IS" BASIS,
00012  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013  * See the License for the specific language governing permissions and
00014  * limitations under the License.
00015  */
00016 #include "platform/platform.h"
00017 #include "platform/FilePath.h"
00018 #include "hal/serial_api.h"
00019 #include "platform/mbed_toolchain.h"
00020 #include "platform/mbed_semihost_api.h"
00021 #include "platform/mbed_interface.h"
00022 #include "platform/SingletonPtr.h"
00023 #include "platform/PlatformMutex.h"
00024 #include "platform/mbed_error.h"
00025 #include "platform/mbed_stats.h"
00026 #include "platform/mbed_critical.h"
00027 #include <stdlib.h>
00028 #include <string.h>
00029 #include <limits.h>
00030 #if DEVICE_STDIO_MESSAGES
00031 #include <stdio.h>
00032 #endif
00033 #include <errno.h>
00034 #include "platform/mbed_retarget.h"
00035 
00036 #if defined(__ARMCC_VERSION)
00037 #   include <rt_sys.h>
00038 #   define PREFIX(x)    _sys##x
00039 #   define OPEN_MAX     _SYS_OPEN
00040 #   ifdef __MICROLIB
00041 #       pragma import(__use_full_stdio)
00042 #   endif
00043 
00044 #elif defined(__ICCARM__)
00045 #   include <yfuns.h>
00046 #   define PREFIX(x)        _##x
00047 #   define OPEN_MAX         16
00048 
00049 #   define STDIN_FILENO     0
00050 #   define STDOUT_FILENO    1
00051 #   define STDERR_FILENO    2
00052 
00053 #else
00054 #   include <sys/stat.h>
00055 #   include <sys/syslimits.h>
00056 #   define PREFIX(x)    x
00057 #endif
00058 
00059 #define FILE_HANDLE_RESERVED    0xFFFFFFFF
00060 
00061 using namespace mbed;
00062 
00063 #if defined(__MICROLIB) && (__ARMCC_VERSION>5030000)
00064 // Before version 5.03, we were using a patched version of microlib with proper names
00065 extern const char __stdin_name[]  = ":tt";
00066 extern const char __stdout_name[] = ":tt";
00067 extern const char __stderr_name[] = ":tt";
00068 
00069 #else
00070 extern const char __stdin_name[]  = "/stdin";
00071 extern const char __stdout_name[] = "/stdout";
00072 extern const char __stderr_name[] = "/stderr";
00073 #endif
00074 
00075 unsigned char *mbed_heap_start = 0;
00076 uint32_t mbed_heap_size = 0;
00077 
00078 /* newlib has the filehandle field in the FILE struct as a short, so
00079  * we can't just return a Filehandle* from _open and instead have to
00080  * put it in a filehandles array and return the index into that array
00081  * (or rather index+3, as filehandles 0-2 are stdin/out/err).
00082  */
00083 static FileHandle *filehandles[OPEN_MAX];
00084 static SingletonPtr<PlatformMutex>  filehandle_mutex;
00085 
00086 namespace mbed {
00087 void remove_filehandle(FileHandle *file) {
00088     filehandle_mutex->lock();
00089     /* Remove all open filehandles for this */
00090     for (unsigned int fh_i = 0; fh_i < sizeof(filehandles)/sizeof(*filehandles); fh_i++) {
00091         if (filehandles[fh_i] == file) {
00092             filehandles[fh_i] = NULL;
00093         }
00094     }
00095     filehandle_mutex->unlock();
00096 }
00097 }
00098 
00099 #if DEVICE_SERIAL
00100 extern int stdio_uart_inited;
00101 extern serial_t stdio_uart;
00102 #if MBED_CONF_PLATFORM_STDIO_CONVERT_NEWLINES
00103 static char stdio_in_prev;
00104 static char stdio_out_prev;
00105 #endif
00106 #endif
00107 
00108 static void init_serial() {
00109 #if DEVICE_SERIAL
00110     if (stdio_uart_inited) return;
00111     serial_init(&stdio_uart, STDIO_UART_TX, STDIO_UART_RX);
00112 #if MBED_CONF_PLATFORM_STDIO_BAUD_RATE
00113     serial_baud(&stdio_uart, MBED_CONF_PLATFORM_STDIO_BAUD_RATE);
00114 #endif
00115 #endif
00116 }
00117 
00118 /**
00119  * Sets errno when file opening fails.
00120  * Wipes out the filehandle too.
00121  *
00122  * @param error is a negative error code returned from an mbed function and
00123  *              will be negated to store a positive error code in errno
00124  */
00125 static int handle_open_errors(int error, unsigned filehandle_idx) {
00126     errno = -error;
00127     // Free file handle
00128     filehandles[filehandle_idx] = NULL;
00129     return -1;
00130 }
00131 
00132 static inline int openmode_to_posix(int openmode) {
00133     int posix = openmode;
00134 #ifdef __ARMCC_VERSION
00135     if (openmode & OPEN_PLUS) {
00136         posix = O_RDWR;
00137     } else if(openmode & OPEN_W) {
00138         posix = O_WRONLY;
00139     } else if(openmode & OPEN_A) {
00140         posix = O_WRONLY|O_APPEND;
00141     } else {
00142         posix = O_RDONLY;
00143     }
00144     /* a, w, a+, w+ all create if file does not already exist */
00145     if (openmode & (OPEN_A|OPEN_W)) {
00146         posix |= O_CREAT;
00147     }
00148     /* w and w+ truncate */
00149     if (openmode & OPEN_W) {
00150         posix |= O_TRUNC;
00151     }
00152 #elif defined(__ICCARM__)
00153     switch (openmode & _LLIO_RDWRMASK) {
00154         case _LLIO_RDONLY: posix = O_RDONLY; break;
00155         case _LLIO_WRONLY: posix = O_WRONLY; break;
00156         case _LLIO_RDWR  : posix = O_RDWR  ; break;
00157     }
00158     if (openmode & _LLIO_CREAT ) posix |= O_CREAT;
00159     if (openmode & _LLIO_APPEND) posix |= O_APPEND;
00160     if (openmode & _LLIO_TRUNC ) posix |= O_TRUNC;
00161 #elif defined(TOOLCHAIN_GCC)
00162     posix &= ~O_BINARY;
00163 #endif
00164     return posix;
00165 }
00166 
00167 /* @brief   standard c library fopen() retargeting function.
00168  *
00169  * This function is invoked by the standard c library retargeting to handle fopen()
00170  *
00171  * @return
00172  *  On success, a valid FILEHANDLE is returned.
00173  *  On failure, -1 is returned and errno is set to an appropriate value e.g.
00174  *   ENOENT     file not found (default errno setting)
00175  *   EMFILE     the maximum number of open files was exceeded.
00176  *
00177  * */
00178 extern "C" FILEHANDLE PREFIX(_open)(const char* name, int openmode) {
00179     #if defined(__MICROLIB) && (__ARMCC_VERSION>5030000)
00180 #if !defined(MBED_CONF_RTOS_PRESENT)
00181     // valid only for mbed 2
00182     // for ulib, this is invoked after RAM init, prior c++
00183     // used as hook, as post stack/heap is not active there
00184     extern void mbed_copy_nvic(void);
00185     extern void mbed_sdk_init(void);
00186 
00187     static int mbed_sdk_inited = 0;
00188     if (!mbed_sdk_inited) {
00189         mbed_copy_nvic();
00190         mbed_sdk_init();
00191         mbed_sdk_inited = 1;
00192     }
00193 #endif
00194     // Before version 5.03, we were using a patched version of microlib with proper names
00195     // This is the workaround that the microlib author suggested us
00196     static int n = 0;
00197     if (!std::strcmp(name, ":tt")) return n++;
00198     #else
00199     /* Use the posix convention that stdin,out,err are filehandles 0,1,2.
00200      */
00201     if (std::strcmp(name, __stdin_name) == 0) {
00202         init_serial();
00203         return 0;
00204     } else if (std::strcmp(name, __stdout_name) == 0) {
00205         init_serial();
00206         return 1;
00207     } else if (std::strcmp(name, __stderr_name) == 0) {
00208         init_serial();
00209         return 2;
00210     }
00211     #endif
00212 
00213     // find the first empty slot in filehandles
00214     filehandle_mutex->lock();
00215     unsigned int fh_i;
00216     for (fh_i = 0; fh_i < sizeof(filehandles)/sizeof(*filehandles); fh_i++) {
00217         /* Take a next free filehandle slot available. */
00218         if (filehandles[fh_i] == NULL) break;
00219     }
00220     if (fh_i >= sizeof(filehandles)/sizeof(*filehandles)) {
00221         /* Too many file handles have been opened */
00222         errno = EMFILE;
00223         filehandle_mutex->unlock();
00224         return -1;
00225     }
00226     filehandles[fh_i] = (FileHandle*)FILE_HANDLE_RESERVED;
00227     filehandle_mutex->unlock();
00228 
00229     FileHandle *res = NULL;
00230 
00231     /* FILENAME: ":0x12345678" describes a FileHandle* */
00232     if (name[0] == ':') {
00233         void *p;
00234         std::sscanf(name, ":%p", &p);
00235         res = (FileHandle*)p;
00236 
00237     /* FILENAME: "/file_system/file_name" */
00238     } else {
00239         FilePath path(name);
00240 
00241         if (!path.exists()) {
00242             /* The first part of the filename (between first 2 '/') is not a
00243              * registered mount point in the namespace.
00244              */
00245             return handle_open_errors(-ENOENT, fh_i);
00246         }
00247 
00248         if (path.isFile()) {
00249             res = path.file();
00250         } else {
00251             FileSystemHandle *fs = path.fileSystem();
00252             if (fs == NULL) {
00253                 return handle_open_errors(-ENOENT, fh_i);
00254             }
00255             int posix_mode = openmode_to_posix(openmode);
00256             int err = fs->open(&res, path.fileName(), posix_mode);
00257             if (err) {
00258                 return handle_open_errors(err, fh_i);
00259             }
00260         }
00261     }
00262 
00263     filehandles[fh_i] = res;
00264 
00265     return fh_i + 3; // +3 as filehandles 0-2 are stdin/out/err
00266 }
00267 
00268 extern "C" int PREFIX(_close)(FILEHANDLE fh) {
00269     if (fh < 3) return 0;
00270 
00271     FileHandle* fhc = filehandles[fh-3];
00272     filehandles[fh-3] = NULL;
00273     if (fhc == NULL) {
00274         errno = EBADF;
00275         return -1;
00276     }
00277 
00278     int err = fhc->close();
00279     if (err < 0) {
00280         errno = -err;
00281         return -1;
00282     } else {
00283         return 0;
00284     }
00285 }
00286 
00287 #if defined(__ICCARM__)
00288 extern "C" size_t    __write (int        fh, const unsigned char *buffer, size_t length) {
00289 #else
00290 extern "C" int PREFIX(_write)(FILEHANDLE fh, const unsigned char *buffer, unsigned int length, int mode) {
00291 #endif
00292     int n; // n is the number of bytes written
00293 
00294 #if defined(MBED_TRAP_ERRORS_ENABLED) && MBED_TRAP_ERRORS_ENABLED && defined(MBED_CONF_RTOS_PRESENT)
00295     if (core_util_is_isr_active() || !core_util_are_interrupts_enabled()) {
00296         error("Error - writing to a file in an ISR or critical section\r\n");
00297     }
00298 #endif
00299 
00300     if (fh < 3) {
00301 #if DEVICE_SERIAL
00302         if (!stdio_uart_inited) init_serial();
00303 #if MBED_CONF_PLATFORM_STDIO_CONVERT_NEWLINES
00304         for (unsigned int i = 0; i < length; i++) {
00305             if (buffer[i] == '\n' && stdio_out_prev != '\r') {
00306                  serial_putc(&stdio_uart, '\r');
00307             }
00308             serial_putc(&stdio_uart, buffer[i]);
00309             stdio_out_prev = buffer[i];
00310         }
00311 #else
00312         for (unsigned int i = 0; i < length; i++) {
00313             serial_putc(&stdio_uart, buffer[i]);
00314         }
00315 #endif
00316 #endif
00317         n = length;
00318     } else {
00319         FileHandle* fhc = filehandles[fh-3];
00320         if (fhc == NULL) {
00321             errno = EBADF;
00322             return -1;
00323         }
00324 
00325         n = fhc->write(buffer, length);
00326         if (n < 0) {
00327             errno = -n;
00328         }
00329     }
00330 #ifdef __ARMCC_VERSION
00331     return length-n;
00332 #else
00333     return n;
00334 #endif
00335 }
00336 
00337 #if defined(__ICCARM__)
00338 extern "C" size_t    __read (int        fh, unsigned char *buffer, size_t       length) {
00339 #else
00340 extern "C" int PREFIX(_read)(FILEHANDLE fh, unsigned char *buffer, unsigned int length, int mode) {
00341 #endif
00342     int n; // n is the number of bytes read
00343 
00344 #if defined(MBED_TRAP_ERRORS_ENABLED) && MBED_TRAP_ERRORS_ENABLED && defined(MBED_CONF_RTOS_PRESENT)
00345     if (core_util_is_isr_active() || !core_util_are_interrupts_enabled()) {
00346         error("Error - reading from a file in an ISR or critical section\r\n");
00347     }
00348 #endif
00349 
00350     if (fh < 3) {
00351         // only read a character at a time from stdin
00352 #if DEVICE_SERIAL
00353         if (!stdio_uart_inited) init_serial();
00354 #if MBED_CONF_PLATFORM_STDIO_CONVERT_NEWLINES
00355         while (true) {
00356             char c = serial_getc(&stdio_uart);
00357             if ((c == '\r' && stdio_in_prev != '\n') ||
00358                 (c == '\n' && stdio_in_prev != '\r')) {
00359                 stdio_in_prev = c;
00360                 *buffer = '\n';
00361                 break;
00362             } else if ((c == '\r' && stdio_in_prev == '\n') ||
00363                        (c == '\n' && stdio_in_prev == '\r')) {
00364                 stdio_in_prev = c;
00365                 // onto next character
00366                 continue;
00367             } else {
00368                 stdio_in_prev = c;
00369                 *buffer = c;
00370                 break;
00371             }
00372         }
00373 #else
00374         *buffer = serial_getc(&stdio_uart);
00375 #endif
00376 #endif
00377         n = 1;
00378     } else {
00379         FileHandle* fhc = filehandles[fh-3];
00380         if (fhc == NULL) {
00381             errno = EBADF;
00382             return -1;
00383         }
00384 
00385         n = fhc->read(buffer, length);
00386         if (n < 0) {
00387             errno = -n;
00388         }
00389     }
00390 #ifdef __ARMCC_VERSION
00391     return length-n;
00392 #else
00393     return n;
00394 #endif
00395 }
00396 
00397 
00398 #ifdef __ARMCC_VERSION
00399 extern "C" int PREFIX(_istty)(FILEHANDLE fh)
00400 #else
00401 extern "C" int _isatty(FILEHANDLE fh)
00402 #endif
00403 {
00404     /* stdin, stdout and stderr should be tty */
00405     if (fh < 3) return 1;
00406 
00407     FileHandle* fhc = filehandles[fh-3];
00408     if (fhc == NULL) {
00409         errno = EBADF;
00410         return 0;
00411     }
00412 
00413     int tty = fhc->isatty();
00414     if (tty < 0) {
00415         errno = -tty;
00416         return 0;
00417     } else {
00418         return tty;
00419     }
00420 }
00421 
00422 extern "C"
00423 #if defined(__ARMCC_VERSION)
00424 int _sys_seek(FILEHANDLE fh, long offset)
00425 #elif defined(__ICCARM__)
00426 long __lseek(int fh, long offset, int whence)
00427 #else
00428 int _lseek(FILEHANDLE fh, int offset, int whence)
00429 #endif
00430 {
00431 #if defined(__ARMCC_VERSION)
00432     int whence = SEEK_SET;
00433 #endif
00434     if (fh < 3) {
00435         errno = ESPIPE;
00436         return -1;
00437     }
00438 
00439     FileHandle* fhc = filehandles[fh-3];
00440     if (fhc == NULL) {
00441         errno = EBADF;
00442         return -1;
00443     }
00444 
00445     off_t off = fhc->seek(offset, whence);
00446     if (off < 0) {
00447         errno = -off;
00448         return -1;
00449     }
00450     // Assuming INT_MAX = LONG_MAX, so we don't care about prototype difference
00451     if (off > INT_MAX) {
00452         errno = EOVERFLOW;
00453         return -1;
00454     }
00455     return off;
00456 }
00457 
00458 #ifdef __ARMCC_VERSION
00459 extern "C" int PREFIX(_ensure)(FILEHANDLE fh) {
00460     if (fh < 3) return 0;
00461 
00462     FileHandle* fhc = filehandles[fh-3];
00463     if (fhc == NULL) {
00464         errno = EBADF;
00465         return -1;
00466     }
00467 
00468     int err = fhc->sync();
00469     if (err < 0) {
00470         errno = -err;
00471         return -1;
00472     } else {
00473         return 0;
00474     }
00475 }
00476 
00477 extern "C" long PREFIX(_flen)(FILEHANDLE fh) {
00478     if (fh < 3) {
00479         errno = EINVAL;
00480         return -1;
00481     }
00482 
00483     FileHandle* fhc = filehandles[fh-3];
00484     if (fhc == NULL) {
00485         errno = EBADF;
00486         return -1;
00487     }
00488 
00489     off_t size = fhc->size();
00490     if (size < 0) {
00491         errno = -size;
00492         return -1;
00493     }
00494     if (size > LONG_MAX) {
00495         errno = EOVERFLOW;
00496         return -1;
00497     }
00498     return size;
00499 }
00500 #endif
00501 
00502 
00503 #if !defined(__ARMCC_VERSION) && !defined(__ICCARM__)
00504 extern "C" int _fstat(int fd, struct stat *st) {
00505     if (fd < 3) {
00506         st->st_mode = S_IFCHR;
00507         return  0;
00508     }
00509     errno = EBADF;
00510     return -1;
00511 }
00512 #endif
00513 
00514 namespace std {
00515 extern "C" int remove(const char *path) {
00516     FilePath fp(path);
00517     FileSystemHandle *fs = fp.fileSystem();
00518     if (fs == NULL) {
00519         errno = ENOENT;
00520         return -1;
00521     }
00522 
00523     int err = fs->remove(fp.fileName());
00524     if (err < 0) {
00525         errno = -err;
00526         return -1;
00527     } else {
00528         return 0;
00529     }
00530 }
00531 
00532 extern "C" int rename(const char *oldname, const char *newname) {
00533     FilePath fpOld(oldname);
00534     FilePath fpNew(newname);
00535     FileSystemHandle *fsOld = fpOld.fileSystem();
00536     FileSystemHandle *fsNew = fpNew.fileSystem();
00537 
00538     if (fsOld == NULL) {
00539         errno = ENOENT;
00540         return -1;
00541     }
00542 
00543     /* rename only if both files are on the same FS */
00544     if (fsOld != fsNew) {
00545         errno = EXDEV;
00546         return -1;
00547     }
00548 
00549     int err = fsOld->rename(fpOld.fileName(), fpNew.fileName());
00550     if (err < 0) {
00551         errno = -err;
00552         return -1;
00553     } else {
00554         return 0;
00555     }
00556 }
00557 
00558 extern "C" char *tmpnam(char *s) {
00559     errno = EBADF;
00560     return NULL;
00561 }
00562 
00563 extern "C" FILE *tmpfile() {
00564     errno = EBADF;
00565     return NULL;
00566 }
00567 } // namespace std
00568 
00569 #ifdef __ARMCC_VERSION
00570 extern "C" char *_sys_command_string(char *cmd, int len) {
00571     return NULL;
00572 }
00573 #endif
00574 
00575 extern "C" DIR *opendir(const char *path) {
00576     FilePath fp(path);
00577     FileSystemHandle* fs = fp.fileSystem();
00578     if (fs == NULL) {
00579         errno = ENOENT;
00580         return NULL;
00581     }
00582 
00583     DirHandle *dir;
00584     int err = fs->open(&dir, fp.fileName());
00585     if (err < 0) {
00586         errno = -err;
00587         return NULL;
00588     }
00589 
00590     return dir;
00591 }
00592 
00593 extern "C" struct dirent *readdir(DIR *dir) {
00594     static struct dirent ent;
00595     int err = dir->read(&ent);
00596     if (err < 1) {
00597         if (err < 0) {
00598             errno = -err;
00599         }
00600         return NULL;
00601     }
00602 
00603     return &ent;
00604 }
00605 
00606 extern "C" int closedir(DIR *dir) {
00607     int err = dir->close();
00608     if (err < 0) {
00609         errno = -err;
00610         return -1;
00611     } else {
00612         return 0;
00613     }
00614 }
00615 
00616 extern "C" void rewinddir(DIR *dir) {
00617     dir->rewind();
00618 }
00619 
00620 extern "C" off_t telldir(DIR *dir) {
00621     return dir->tell();
00622 }
00623 
00624 extern "C" void seekdir(DIR *dir, off_t off) {
00625     dir->seek(off);
00626 }
00627 
00628 extern "C" int mkdir(const char *path, mode_t mode) {
00629     FilePath fp(path);
00630     FileSystemHandle *fs = fp.fileSystem();
00631     if (fs == NULL) return -1;
00632 
00633     int err = fs->mkdir(fp.fileName(), mode);
00634     if (err < 0) {
00635         errno = -err;
00636         return -1;
00637     } else {
00638         return 0;
00639     }
00640 }
00641 
00642 extern "C" int stat(const char *path, struct stat *st) {
00643     FilePath fp(path);
00644     FileSystemHandle *fs = fp.fileSystem();
00645     if (fs == NULL) return -1;
00646 
00647     int err = fs->stat(fp.fileName(), st);
00648     if (err < 0) {
00649         errno = -err;
00650         return -1;
00651     } else {
00652         return 0;
00653     }
00654 }
00655 
00656 #if defined(TOOLCHAIN_GCC)
00657 /* prevents the exception handling name demangling code getting pulled in */
00658 #include "mbed_error.h"
00659 namespace __gnu_cxx {
00660     void __verbose_terminate_handler() {
00661         error("Exception");
00662     }
00663 }
00664 extern "C" WEAK void __cxa_pure_virtual(void);
00665 extern "C" WEAK void __cxa_pure_virtual(void) {
00666     exit(1);
00667 }
00668 
00669 #endif
00670 
00671 // Provide implementation of _sbrk (low-level dynamic memory allocation
00672 // routine) for GCC_ARM which compares new heap pointer with MSP instead of
00673 // SP.  This make it compatible with RTX RTOS thread stacks.
00674 #if defined(TOOLCHAIN_GCC_ARM) || defined(TOOLCHAIN_GCC_CR)
00675 
00676 #if defined(TARGET_CORTEX_A)
00677 extern "C" uint32_t  __HeapLimit;
00678 #endif
00679 
00680 // Turn off the errno macro and use actual global variable instead.
00681 #undef errno
00682 extern "C" int errno;
00683 
00684 // Dynamic memory allocation related syscall.
00685 #if defined(TARGET_NUMAKER_PFM_NUC472) || defined(TARGET_NUMAKER_PFM_M453)
00686 // Overwrite _sbrk() to support two region model (heap and stack are two distinct regions).
00687 // __wrap__sbrk() is implemented in:
00688 // TARGET_NUMAKER_PFM_NUC472    hal/targets/cmsis/TARGET_NUVOTON/TARGET_NUC472/TARGET_NUMAKER_PFM_NUC472/TOOLCHAIN_GCC_ARM/retarget.c
00689 // TARGET_NUMAKER_PFM_M453      hal/targets/cmsis/TARGET_NUVOTON/TARGET_M451/TARGET_NUMAKER_PFM_M453/TOOLCHAIN_GCC_ARM/retarget.c
00690 extern "C" void *__wrap__sbrk(int incr);
00691 extern "C" caddr_t _sbrk(int incr) {
00692     return (caddr_t) __wrap__sbrk(incr);
00693 }
00694 #else
00695 // Linker defined symbol used by _sbrk to indicate where heap should start.
00696 extern "C" uint32_t __end__;
00697 extern "C" caddr_t _sbrk(int incr) {
00698     static unsigned char* heap = (unsigned char*)&__end__;
00699     unsigned char*        prev_heap = heap;
00700     unsigned char*        new_heap = heap + incr;
00701 
00702 #if defined(TARGET_CORTEX_A)
00703     if (new_heap >= (unsigned char*)&__HeapLimit) {     /* __HeapLimit is end of heap section */
00704 #else
00705     if (new_heap >= (unsigned char*)__get_MSP()) {
00706 #endif
00707         errno = ENOMEM;
00708         return (caddr_t)-1;
00709     }
00710 
00711     // Additional heap checking if set
00712     if (mbed_heap_size && (new_heap >= mbed_heap_start + mbed_heap_size)) {
00713         errno = ENOMEM;
00714         return (caddr_t)-1;
00715     }
00716 
00717     heap = new_heap;
00718     return (caddr_t) prev_heap;
00719 }
00720 #endif
00721 #endif
00722 
00723 #if defined(TOOLCHAIN_GCC_ARM) || defined(TOOLCHAIN_GCC_CR)
00724 extern "C" void _exit(int return_code) {
00725 #else
00726 namespace std {
00727 extern "C" void exit(int return_code) {
00728 #endif
00729 
00730 #if DEVICE_STDIO_MESSAGES
00731 #if MBED_CONF_PLATFORM_STDIO_FLUSH_AT_EXIT
00732     fflush(stdout);
00733     fflush(stderr);
00734 #endif
00735 #endif
00736 
00737 #if DEVICE_SEMIHOST
00738     if (mbed_interface_connected()) {
00739         semihost_exit();
00740     }
00741 #endif
00742     if (return_code) {
00743         mbed_die();
00744     }
00745 
00746     while (1);
00747 }
00748 
00749 #if !defined(TOOLCHAIN_GCC_ARM) && !defined(TOOLCHAIN_GCC_CR)
00750 } //namespace std
00751 #endif
00752 
00753 #if defined(TOOLCHAIN_ARM) || defined(TOOLCHAIN_GCC)
00754 
00755 // This series of function disable the registration of global destructors
00756 // in a dynamic table which will be called when the application exit.
00757 // In mbed, program never exit properly, it dies.
00758 // More informations about this topic for ARMCC here:
00759 // http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.faqs/6449.html
00760 extern "C" {
00761 int __aeabi_atexit(void *object, void (*dtor)(void* /*this*/), void *handle) {
00762     return 1;
00763 }
00764 
00765 int __cxa_atexit(void (*dtor)(void* /*this*/), void *object, void *handle) {
00766     return 1;
00767 }
00768 
00769 void __cxa_finalize(void *handle) {
00770 }
00771 
00772 } // end of extern "C"
00773 
00774 #endif
00775 
00776 
00777 #if defined(TOOLCHAIN_GCC)
00778 
00779 /*
00780  * Depending on how newlib is  configured, it is often not enough to define
00781  * __aeabi_atexit, __cxa_atexit and __cxa_finalize in order to override the
00782  * behavior regarding the registration of handlers with atexit.
00783  *
00784  * To overcome this limitation, exit and atexit are overriden here.
00785  */
00786 extern "C"{
00787 
00788 /**
00789  * @brief Retarget of exit for GCC.
00790  * @details Unlike the standard version, this function doesn't call any function
00791  * registered with atexit before calling _exit.
00792  */
00793 void __wrap_exit(int return_code) {
00794     _exit(return_code);
00795 }
00796 
00797 /**
00798  * @brief Retarget atexit from GCC.
00799  * @details This function will always fail and never register any handler to be
00800  * called at exit.
00801  */
00802 int __wrap_atexit(void (*func)()) {
00803     return 1;
00804 }
00805 
00806 }
00807 
00808 #endif
00809 
00810 
00811 
00812 namespace mbed {
00813 
00814 void mbed_set_unbuffered_stream(std::FILE *_file) {
00815 #if defined (__ICCARM__)
00816     char buf[2];
00817     std::setvbuf(_file,buf,_IONBF,NULL);
00818 #else
00819     setbuf(_file, NULL);
00820 #endif
00821 }
00822 
00823 /* Applications are expected to use fdopen()
00824  * not this function directly. This code had to live here because FILE and FileHandle
00825  * processes are all linked together here.
00826  */
00827 std::FILE *mbed_fdopen(FileHandle *fh, const char *mode)
00828 {
00829     char buf[12]; /* :0x12345678 + null byte */
00830     std::sprintf(buf, ":%p", fh);
00831     std::FILE *stream = std::fopen(buf, mode);
00832     /* newlib-nano doesn't appear to ever call _isatty itself, so
00833      * happily fully buffers an interactive stream. Deal with that here.
00834      */
00835     if (stream && fh->isatty()) {
00836         mbed_set_unbuffered_stream(stream);
00837     }
00838     return stream;
00839 }
00840 
00841 int mbed_getc(std::FILE *_file){
00842 #if defined (__ICCARM__)
00843     /*This is only valid for unbuffered streams*/
00844     int res = std::fgetc(_file);
00845     if (res>=0){
00846         _file->_Mode = (unsigned short)(_file->_Mode & ~ 0x1000);/* Unset read mode */
00847         _file->_Rend = _file->_Wend;
00848         _file->_Next = _file->_Wend;
00849     }
00850     return res;
00851 #else
00852     return std::fgetc(_file);
00853 #endif
00854 }
00855 
00856 char* mbed_gets(char*s, int size, std::FILE *_file){
00857 #if defined (__ICCARM__)
00858     /*This is only valid for unbuffered streams*/
00859     char *str = fgets(s,size,_file);
00860     if (str!=NULL){
00861         _file->_Mode = (unsigned short)(_file->_Mode & ~ 0x1000);/* Unset read mode */
00862         _file->_Rend = _file->_Wend;
00863         _file->_Next = _file->_Wend;
00864     }
00865     return str;
00866 #else
00867     return std::fgets(s,size,_file);
00868 #endif
00869 }
00870 
00871 } // namespace mbed
00872 
00873 #if defined (__ICCARM__)
00874 // Stub out locks when an rtos is not present
00875 extern "C" WEAK void __iar_system_Mtxinit(__iar_Rmtx *mutex) {}
00876 extern "C" WEAK void __iar_system_Mtxdst(__iar_Rmtx *mutex) {}
00877 extern "C" WEAK void __iar_system_Mtxlock(__iar_Rmtx *mutex) {}
00878 extern "C" WEAK void __iar_system_Mtxunlock(__iar_Rmtx *mutex) {}
00879 extern "C" WEAK void __iar_file_Mtxinit(__iar_Rmtx *mutex) {}
00880 extern "C" WEAK void __iar_file_Mtxdst(__iar_Rmtx *mutex) {}
00881 extern "C" WEAK void __iar_file_Mtxlock(__iar_Rmtx *mutex) {}
00882 extern "C" WEAK void __iar_file_Mtxunlock(__iar_Rmtx *mutex) {}
00883 #elif defined(__CC_ARM)
00884 // Do nothing
00885 #elif defined (__GNUC__)
00886 struct _reent;
00887 // Stub out locks when an rtos is not present
00888 extern "C" WEAK void __rtos_malloc_lock( struct _reent *_r ) {}
00889 extern "C" WEAK void __rtos_malloc_unlock( struct _reent *_r ) {}
00890 extern "C" WEAK void __rtos_env_lock( struct _reent *_r ) {}
00891 extern "C" WEAK void __rtos_env_unlock( struct _reent *_r ) {}
00892 
00893 extern "C" void __malloc_lock( struct _reent *_r )
00894 {
00895     __rtos_malloc_lock(_r);
00896 }
00897 
00898 extern "C" void __malloc_unlock( struct _reent *_r )
00899 {
00900     __rtos_malloc_unlock(_r);
00901 }
00902 
00903 extern "C" void __env_lock( struct _reent *_r )
00904 {
00905     __rtos_env_lock(_r);
00906 }
00907 
00908 extern "C" void __env_unlock( struct _reent *_r )
00909 {
00910     __rtos_env_unlock(_r);
00911 }
00912 
00913 #define CXA_GUARD_INIT_DONE             (1 << 0)
00914 #define CXA_GUARD_INIT_IN_PROGRESS      (1 << 1)
00915 #define CXA_GUARD_MASK                  (CXA_GUARD_INIT_DONE | CXA_GUARD_INIT_IN_PROGRESS)
00916 
00917 extern "C" int __cxa_guard_acquire(int *guard_object_p)
00918 {
00919     uint8_t *guard_object = (uint8_t *)guard_object_p;
00920     if (CXA_GUARD_INIT_DONE == (*guard_object & CXA_GUARD_MASK)) {
00921         return 0;
00922     }
00923     singleton_lock();
00924     if (CXA_GUARD_INIT_DONE == (*guard_object & CXA_GUARD_MASK)) {
00925         singleton_unlock();
00926         return 0;
00927     }
00928     MBED_ASSERT(0 == (*guard_object & CXA_GUARD_MASK));
00929     *guard_object = *guard_object | CXA_GUARD_INIT_IN_PROGRESS;
00930     return 1;
00931 }
00932 
00933 extern "C" void __cxa_guard_release(int *guard_object_p)
00934 {
00935     uint8_t *guard_object = (uint8_t *)guard_object_p;
00936     MBED_ASSERT(CXA_GUARD_INIT_IN_PROGRESS == (*guard_object & CXA_GUARD_MASK));
00937     *guard_object = (*guard_object & ~CXA_GUARD_MASK) | CXA_GUARD_INIT_DONE;
00938     singleton_unlock();
00939 }
00940 
00941 extern "C" void __cxa_guard_abort(int *guard_object_p)
00942 {
00943     uint8_t *guard_object = (uint8_t *)guard_object_p;
00944     MBED_ASSERT(CXA_GUARD_INIT_IN_PROGRESS == (*guard_object & CXA_GUARD_MASK));
00945     *guard_object = *guard_object & ~CXA_GUARD_INIT_IN_PROGRESS;
00946     singleton_unlock();
00947 }
00948 
00949 #endif
00950 
00951 void *operator new(std::size_t count)
00952 {
00953     void *buffer = malloc(count);
00954     if (NULL == buffer) {
00955         error("Operator new out of memory\r\n");
00956     }
00957     return buffer;
00958 }
00959 
00960 void *operator new[](std::size_t count)
00961 {
00962     void *buffer = malloc(count);
00963     if (NULL == buffer) {
00964         error("Operator new[] out of memory\r\n");
00965     }
00966     return buffer;
00967 }
00968 
00969 void operator delete(void *ptr)
00970 {
00971     if (ptr != NULL) {
00972         free(ptr);
00973     }
00974 }
00975 void operator delete[](void *ptr)
00976 {
00977     if (ptr != NULL) {
00978         free(ptr);
00979     }
00980 }
00981 
00982 #if defined(MBED_CONF_RTOS_PRESENT) && defined(MBED_TRAP_ERRORS_ENABLED) && MBED_TRAP_ERRORS_ENABLED
00983 
00984 static const char* error_msg(int32_t status)
00985 {
00986     switch (status) {
00987     case osError:
00988         return "Unspecified RTOS error";
00989     case osErrorTimeout:
00990         return "Operation not completed within the timeout period";
00991     case osErrorResource:
00992         return "Resource not available";
00993     case osErrorParameter:
00994         return "Parameter error";
00995     case osErrorNoMemory:
00996         return "System is out of memory";
00997     case osErrorISR:
00998         return "Not allowed in ISR context";
00999     default:
01000         return "Unknown";
01001     }
01002 }
01003 
01004 extern "C" void EvrRtxKernelError (int32_t status)
01005 {
01006     error("Kernel error %i: %s\r\n", status, error_msg(status));
01007 }
01008 
01009 extern "C" void EvrRtxThreadError (osThreadId_t thread_id, int32_t status)
01010 {
01011     error("Thread %p error %i: %s\r\n", thread_id, status, error_msg(status));
01012 }
01013 
01014 extern "C" void EvrRtxTimerError (osTimerId_t timer_id, int32_t status)
01015 {
01016     error("Timer %p error %i: %s\r\n", timer_id, status, error_msg(status));
01017 }
01018 
01019 extern "C" void EvrRtxEventFlagsError (osEventFlagsId_t ef_id, int32_t status)
01020 {
01021     error("Event %p error %i: %s\r\n", ef_id, status, error_msg(status));
01022 }
01023 
01024 extern "C" void EvrRtxMutexError (osMutexId_t mutex_id, int32_t status)
01025 {
01026     error("Mutex %p error %i: %s\r\n", mutex_id, status, error_msg(status));
01027 }
01028 
01029 extern "C" void EvrRtxSemaphoreError (osSemaphoreId_t semaphore_id, int32_t status)
01030 {
01031     // Ignore semaphore overflow, the count will saturate with a returned error
01032     if (status == osRtxErrorSemaphoreCountLimit) {
01033         return;
01034     }
01035 
01036     error("Semaphore %p error %i\r\n", semaphore_id, status);
01037 }
01038 
01039 extern "C" void EvrRtxMemoryPoolError (osMemoryPoolId_t mp_id, int32_t status)
01040 {
01041     error("Memory Pool %p error %i\r\n", mp_id, status);
01042 }
01043 
01044 extern "C" void EvrRtxMessageQueueError (osMessageQueueId_t mq_id, int32_t status)
01045 {
01046     error("Message Queue %p error %i\r\n", mq_id, status);
01047 }
01048 
01049 #endif