Update LVGL to v9.1.0

5 files changed, 2735 insertions, 0 deletions

diff --git a/lib/lvgl/src/stdlib/builtin/lv_mem_core_builtin.c b/lib/lvgl/src/stdlib/builtin/lv_mem_core_builtin.c
new file mode 100644
index 00000000..b7b707de
--- /dev/null
+++ b/lib/lvgl/src/stdlib/builtin/lv_mem_core_builtin.c
@@ -0,0 +1,273 @@
+/**
+ * @file lv_malloc_core.c
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../lv_mem.h"
+#if LV_USE_STDLIB_MALLOC == LV_STDLIB_BUILTIN
+
+#include "lv_tlsf.h"
+#include "../lv_string.h"
+#include "../../misc/lv_assert.h"
+#include "../../misc/lv_log.h"
+#include "../../misc/lv_ll.h"
+#include "../../misc/lv_math.h"
+#include "../../osal/lv_os.h"
+#include "../../core/lv_global.h"
+
+#ifdef LV_MEM_POOL_INCLUDE
+    #include LV_MEM_POOL_INCLUDE
+#endif
+
+/*********************
+ *      DEFINES
+ *********************/
+/*memset the allocated memories to 0xaa and freed memories to 0xbb (just for testing purposes)*/
+#ifndef LV_MEM_ADD_JUNK
+    #define LV_MEM_ADD_JUNK  0
+#endif
+
+#ifdef LV_ARCH_64
+    #define MEM_UNIT         uint64_t
+    #define ALIGN_MASK       0x7
+#else
+    #define MEM_UNIT         uint32_t
+    #define ALIGN_MASK       0x3
+#endif
+#define state LV_GLOBAL_DEFAULT()->tlsf_state
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static void lv_mem_walker(void * ptr, size_t size, int used, void * user);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+#if LV_USE_LOG && LV_LOG_TRACE_MEM
+    #define LV_TRACE_MEM(...) LV_LOG_TRACE(__VA_ARGS__)
+#else
+    #define LV_TRACE_MEM(...)
+#endif
+
+#define _COPY(d, s) *d = *s; d++; s++;
+#define _SET(d, v) *d = v; d++;
+#define _REPEAT8(expr) expr expr expr expr expr expr expr expr
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_mem_init(void)
+{
+#if LV_USE_OS
+    lv_mutex_init(&state.mutex);
+#endif
+
+#if LV_MEM_ADR == 0
+#ifdef LV_MEM_POOL_ALLOC
+    state.tlsf = lv_tlsf_create_with_pool((void *)LV_MEM_POOL_ALLOC(LV_MEM_SIZE), LV_MEM_SIZE);
+#else
+    /*Allocate a large array to store the dynamically allocated data*/
+    static LV_ATTRIBUTE_LARGE_RAM_ARRAY MEM_UNIT work_mem_int[LV_MEM_SIZE / sizeof(MEM_UNIT)];
+    state.tlsf = lv_tlsf_create_with_pool((void *)work_mem_int, LV_MEM_SIZE);
+#endif
+#else
+    state.tlsf = lv_tlsf_create_with_pool((void *)LV_MEM_ADR, LV_MEM_SIZE);
+#endif
+
+    _lv_ll_init(&state.pool_ll, sizeof(lv_pool_t));
+
+    /*Record the first pool*/
+    lv_pool_t * pool_p = _lv_ll_ins_tail(&state.pool_ll);
+    LV_ASSERT_MALLOC(pool_p);
+    *pool_p = lv_tlsf_get_pool(state.tlsf);
+
+#if LV_MEM_ADD_JUNK
+    LV_LOG_WARN("LV_MEM_ADD_JUNK is enabled which makes LVGL much slower");
+#endif
+}
+
+void lv_mem_deinit(void)
+{
+    _lv_ll_clear(&state.pool_ll);
+    lv_tlsf_destroy(state.tlsf);
+#if LV_USE_OS
+    lv_mutex_delete(&state.mutex);
+#endif
+}
+
+lv_mem_pool_t lv_mem_add_pool(void * mem, size_t bytes)
+{
+    lv_mem_pool_t new_pool = lv_tlsf_add_pool(state.tlsf, mem, bytes);
+    if(!new_pool) {
+        LV_LOG_WARN("failed to add memory pool, address: %p, size: %zu", mem, bytes);
+        return NULL;
+    }
+
+    lv_pool_t * pool_p = _lv_ll_ins_tail(&state.pool_ll);
+    LV_ASSERT_MALLOC(pool_p);
+    *pool_p = new_pool;
+
+    return new_pool;
+}
+
+void lv_mem_remove_pool(lv_mem_pool_t pool)
+{
+    lv_pool_t * pool_p;
+    _LV_LL_READ(&state.pool_ll, pool_p) {
+        if(*pool_p == pool) {
+            _lv_ll_remove(&state.pool_ll, pool_p);
+            lv_free(pool_p);
+            lv_tlsf_remove_pool(state.tlsf, pool);
+            return;
+        }
+    }
+    LV_LOG_WARN("invalid pool: %p", pool);
+}
+
+void * lv_malloc_core(size_t size)
+{
+#if LV_USE_OS
+    lv_mutex_lock(&state.mutex);
+#endif
+    void * p = lv_tlsf_malloc(state.tlsf, size);
+
+    if(p) {
+        state.cur_used += lv_tlsf_block_size(p);
+        state.max_used = LV_MAX(state.cur_used, state.max_used);
+    }
+
+#if LV_USE_OS
+    lv_mutex_unlock(&state.mutex);
+#endif
+    return p;
+}
+
+void * lv_realloc_core(void * p, size_t new_size)
+{
+#if LV_USE_OS
+    lv_mutex_lock(&state.mutex);
+#endif
+
+    size_t old_size = lv_tlsf_block_size(p);
+    void * p_new = lv_tlsf_realloc(state.tlsf, p, new_size);
+
+    if(p_new) {
+        state.cur_used -= old_size;
+        state.cur_used += lv_tlsf_block_size(p_new);
+        state.max_used = LV_MAX(state.cur_used, state.max_used);
+    }
+#if LV_USE_OS
+    lv_mutex_unlock(&state.mutex);
+#endif
+
+    return p_new;
+}
+
+void lv_free_core(void * p)
+{
+#if LV_USE_OS
+    lv_mutex_lock(&state.mutex);
+#endif
+
+#if LV_MEM_ADD_JUNK
+    lv_memset(p, 0xbb, lv_tlsf_block_size(data));
+#endif
+    size_t size = lv_tlsf_block_size(p);
+    lv_tlsf_free(state.tlsf, p);
+    if(state.cur_used > size) state.cur_used -= size;
+    else state.cur_used = 0;
+
+#if LV_USE_OS
+    lv_mutex_unlock(&state.mutex);
+#endif
+}
+
+void lv_mem_monitor_core(lv_mem_monitor_t * mon_p)
+{
+    /*Init the data*/
+    lv_memzero(mon_p, sizeof(lv_mem_monitor_t));
+    LV_TRACE_MEM("begin");
+
+    lv_pool_t * pool_p;
+    _LV_LL_READ(&state.pool_ll, pool_p) {
+        lv_tlsf_walk_pool(*pool_p, lv_mem_walker, mon_p);
+    }
+
+    mon_p->used_pct = 100 - (uint64_t)100U * mon_p->free_size / mon_p->total_size;
+    if(mon_p->free_size > 0) {
+        mon_p->frag_pct = (uint64_t)mon_p->free_biggest_size * 100U / mon_p->free_size;
+        mon_p->frag_pct = 100 - mon_p->frag_pct;
+    }
+    else {
+        mon_p->frag_pct = 0; /*no fragmentation if all the RAM is used*/
+    }
+
+    mon_p->max_used = state.max_used;
+
+    LV_TRACE_MEM("finished");
+}
+
+lv_result_t lv_mem_test_core(void)
+{
+#if LV_USE_OS
+    lv_mutex_lock(&state.mutex);
+#endif
+    if(lv_tlsf_check(state.tlsf)) {
+        LV_LOG_WARN("failed");
+#if LV_USE_OS
+        lv_mutex_unlock(&state.mutex);
+#endif
+        return LV_RESULT_INVALID;
+    }
+
+    lv_pool_t * pool_p;
+    _LV_LL_READ(&state.pool_ll, pool_p) {
+        if(lv_tlsf_check_pool(*pool_p)) {
+            LV_LOG_WARN("pool failed");
+#if LV_USE_OS
+            lv_mutex_unlock(&state.mutex);
+#endif
+            return LV_RESULT_INVALID;
+        }
+    }
+
+    LV_TRACE_MEM("passed");
+#if LV_USE_OS
+    lv_mutex_unlock(&state.mutex);
+#endif
+    return LV_RESULT_OK;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static void lv_mem_walker(void * ptr, size_t size, int used, void * user)
+{
+    LV_UNUSED(ptr);
+
+    lv_mem_monitor_t * mon_p = user;
+    mon_p->total_size += size;
+    if(used) {
+        mon_p->used_cnt++;
+    }
+    else {
+        mon_p->free_cnt++;
+        mon_p->free_size += size;
+        if(size > mon_p->free_biggest_size)
+            mon_p->free_biggest_size = size;
+    }
+}
+#endif /*LV_STDLIB_BUILTIN*/
diff --git a/lib/lvgl/src/stdlib/builtin/lv_sprintf_builtin.c b/lib/lvgl/src/stdlib/builtin/lv_sprintf_builtin.c
new file mode 100644
index 00000000..d5fc5553
--- /dev/null
+++ b/lib/lvgl/src/stdlib/builtin/lv_sprintf_builtin.c
@@ -0,0 +1,886 @@
+///////////////////////////////////////////////////////////////////////////////
+// \author (c) Marco Paland (info@paland.com)
+//             2014-2019, PALANDesign Hannover, Germany
+//
+// \license The MIT License (MIT)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// \brief Tiny printf, sprintf and (v)snprintf implementation, optimized for speed on
+//        embedded systems with a very limited resources. These routines are thread
+//        safe and reentrant!
+//        Use this instead of the bloated standard/newlib printf cause these use
+//        malloc for printf (and may not be thread safe).
+//
+///////////////////////////////////////////////////////////////////////////////
+
+/*Original repository: https://github.com/mpaland/printf*/
+
+#include "../../lv_conf_internal.h"
+#if LV_USE_STDLIB_SPRINTF == LV_STDLIB_BUILTIN
+
+#include "../lv_sprintf.h"
+#include "../../misc/lv_types.h"
+
+#define PRINTF_DISABLE_SUPPORT_FLOAT    (!LV_USE_FLOAT)
+
+// 'ntoa' conversion buffer size, this must be big enough to hold one converted
+// numeric number including padded zeros (dynamically created on stack)
+// default: 32 byte
+#ifndef PRINTF_NTOA_BUFFER_SIZE
+    #define PRINTF_NTOA_BUFFER_SIZE    32U
+#endif
+
+// 'ftoa' conversion buffer size, this must be big enough to hold one converted
+// float number including padded zeros (dynamically created on stack)
+// default: 32 byte
+#ifndef PRINTF_FTOA_BUFFER_SIZE
+    #define PRINTF_FTOA_BUFFER_SIZE    32U
+#endif
+
+// support for the floating point type (%f)
+// default: activated
+#if !PRINTF_DISABLE_SUPPORT_FLOAT
+    #define PRINTF_SUPPORT_FLOAT
+#endif
+
+// support for exponential floating point notation (%e/%g)
+// default: activated
+#ifndef PRINTF_DISABLE_SUPPORT_EXPONENTIAL
+    #define PRINTF_SUPPORT_EXPONENTIAL
+#endif
+
+// define the default floating point precision
+// default: 6 digits
+#ifndef PRINTF_DEFAULT_FLOAT_PRECISION
+    #define PRINTF_DEFAULT_FLOAT_PRECISION 6U
+#endif
+
+// define the largest float suitable to print with %f
+// default: 1e9
+#ifndef PRINTF_MAX_FLOAT
+    #define PRINTF_MAX_FLOAT 1e9
+#endif
+
+// support for the long long types (%llu or %p)
+// default: activated
+#ifndef PRINTF_DISABLE_SUPPORT_LONG_LONG
+    #define PRINTF_SUPPORT_LONG_LONG
+#endif
+
+// support for the ptrdiff_t type (%t)
+// ptrdiff_t is normally defined in <stddef.h> as long or long long type
+// default: activated
+#ifndef PRINTF_DISABLE_SUPPORT_PTRDIFF_T
+    #define PRINTF_SUPPORT_PTRDIFF_T
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
+// internal flag definitions
+#define FLAGS_ZEROPAD   (1U <<  0U)
+#define FLAGS_LEFT      (1U <<  1U)
+#define FLAGS_PLUS      (1U <<  2U)
+#define FLAGS_SPACE     (1U <<  3U)
+#define FLAGS_HASH      (1U <<  4U)
+#define FLAGS_UPPERCASE (1U <<  5U)
+#define FLAGS_CHAR      (1U <<  6U)
+#define FLAGS_SHORT     (1U <<  7U)
+#define FLAGS_LONG      (1U <<  8U)
+#define FLAGS_LONG_LONG (1U <<  9U)
+#define FLAGS_PRECISION (1U << 10U)
+#define FLAGS_ADAPT_EXP (1U << 11U)
+
+typedef struct {
+    const char * fmt;
+    va_list * va;
+} lv_vaformat_t;
+
+// import float.h for DBL_MAX
+#if defined(PRINTF_SUPPORT_FLOAT)
+    #include <float.h>
+#endif
+
+// output function type
+typedef void (*out_fct_type)(char character, void * buffer, size_t idx, size_t maxlen);
+
+// wrapper (used as buffer) for output function type
+typedef struct {
+    void (*fct)(char character, void * arg);
+    void * arg;
+} out_fct_wrap_type;
+
+// internal buffer output
+static inline void _out_buffer(char character, void * buffer, size_t idx, size_t maxlen)
+{
+    if(idx < maxlen) {
+        ((char *)buffer)[idx] = character;
+    }
+}
+
+// internal null output
+static inline void _out_null(char character, void * buffer, size_t idx, size_t maxlen)
+{
+    LV_UNUSED(character);
+    LV_UNUSED(buffer);
+    LV_UNUSED(idx);
+    LV_UNUSED(maxlen);
+}
+
+// internal secure strlen
+// \return The length of the string (excluding the terminating 0) limited by 'maxsize'
+static inline unsigned int _strnlen_s(const char * str, size_t maxsize)
+{
+    const char * s;
+    for(s = str; *s && maxsize--; ++s);
+    return (unsigned int)(s - str);
+}
+
+// internal test if char is a digit (0-9)
+// \return true if char is a digit
+static inline bool _is_digit(char ch)
+{
+    return (ch >= '0') && (ch <= '9');
+}
+
+// internal ASCII string to unsigned int conversion
+static unsigned int _atoi(const char ** str)
+{
+    unsigned int i = 0U;
+    while(_is_digit(**str)) {
+        i = i * 10U + (unsigned int)(*((*str)++) - '0');
+    }
+    return i;
+}
+
+// output the specified string in reverse, taking care of any zero-padding
+static size_t _out_rev(out_fct_type out, char * buffer, size_t idx, size_t maxlen, const char * buf, size_t len,
+                       unsigned int width, unsigned int flags)
+{
+    const size_t start_idx = idx;
+
+    // pad spaces up to given width
+    if(!(flags & FLAGS_LEFT) && !(flags & FLAGS_ZEROPAD)) {
+        size_t i;
+        for(i = len; i < width; i++) {
+            out(' ', buffer, idx++, maxlen);
+        }
+    }
+
+    // reverse string
+    while(len) {
+        out(buf[--len], buffer, idx++, maxlen);
+    }
+
+    // append pad spaces up to given width
+    if(flags & FLAGS_LEFT) {
+        while(idx - start_idx < width) {
+            out(' ', buffer, idx++, maxlen);
+        }
+    }
+
+    return idx;
+}
+
+// internal itoa format
+static size_t _ntoa_format(out_fct_type out, char * buffer, size_t idx, size_t maxlen, char * buf, size_t len,
+                           bool negative, unsigned int base, unsigned int prec, unsigned int width, unsigned int flags)
+{
+    // pad leading zeros
+    if(!(flags & FLAGS_LEFT)) {
+        if(width && (flags & FLAGS_ZEROPAD) && (negative || (flags & (FLAGS_PLUS | FLAGS_SPACE)))) {
+            width--;
+        }
+        while((len < prec) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
+            buf[len++] = '0';
+        }
+        while((flags & FLAGS_ZEROPAD) && (len < width) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
+            buf[len++] = '0';
+        }
+    }
+
+    // handle hash
+    if(flags & FLAGS_HASH) {
+        if(!(flags & FLAGS_PRECISION) && len && ((len == prec) || (len == width))) {
+            len--;
+            if(len && (base == 16U)) {
+                len--;
+            }
+        }
+        if((base == 16U) && !(flags & FLAGS_UPPERCASE) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
+            buf[len++] = 'x';
+        }
+        else if((base == 16U) && (flags & FLAGS_UPPERCASE) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
+            buf[len++] = 'X';
+        }
+        else if((base == 2U) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
+            buf[len++] = 'b';
+        }
+        if(len < PRINTF_NTOA_BUFFER_SIZE) {
+            buf[len++] = '0';
+        }
+    }
+
+    if(len < PRINTF_NTOA_BUFFER_SIZE) {
+        if(negative) {
+            buf[len++] = '-';
+        }
+        else if(flags & FLAGS_PLUS) {
+            buf[len++] = '+';  // ignore the space if the '+' exists
+        }
+        else if(flags & FLAGS_SPACE) {
+            buf[len++] = ' ';
+        }
+    }
+
+    return _out_rev(out, buffer, idx, maxlen, buf, len, width, flags);
+}
+
+// internal itoa for 'long' type
+static size_t _ntoa_long(out_fct_type out, char * buffer, size_t idx, size_t maxlen, unsigned long value, bool negative,
+                         unsigned long base, unsigned int prec, unsigned int width, unsigned int flags)
+{
+    char buf[PRINTF_NTOA_BUFFER_SIZE];
+    size_t len = 0U;
+
+    // no hash for 0 values
+    if(!value) {
+        flags &= ~FLAGS_HASH;
+    }
+
+    // write if precision != 0 and value is != 0
+    if(!(flags & FLAGS_PRECISION) || value) {
+        do {
+            const char digit = (char)(value % base);
+            buf[len++] = digit < 10 ? '0' + digit : (flags & FLAGS_UPPERCASE ? 'A' : 'a') + digit - 10;
+            value /= base;
+        } while(value && (len < PRINTF_NTOA_BUFFER_SIZE));
+    }
+
+    return _ntoa_format(out, buffer, idx, maxlen, buf, len, negative, (unsigned int)base, prec, width, flags);
+}
+
+// internal itoa for 'long long' type
+#if defined(PRINTF_SUPPORT_LONG_LONG)
+static size_t _ntoa_long_long(out_fct_type out, char * buffer, size_t idx, size_t maxlen, unsigned long long value,
+                              bool negative, unsigned long long base, unsigned int prec, unsigned int width, unsigned int flags)
+{
+    char buf[PRINTF_NTOA_BUFFER_SIZE];
+    size_t len = 0U;
+
+    // no hash for 0 values
+    if(!value) {
+        flags &= ~FLAGS_HASH;
+    }
+
+    // write if precision != 0 and value is != 0
+    if(!(flags & FLAGS_PRECISION) || value) {
+        do {
+            const char digit = (char)(value % base);
+            buf[len++] = digit < 10 ? '0' + digit : (flags & FLAGS_UPPERCASE ? 'A' : 'a') + digit - 10;
+            value /= base;
+        } while(value && (len < PRINTF_NTOA_BUFFER_SIZE));
+    }
+
+    return _ntoa_format(out, buffer, idx, maxlen, buf, len, negative, (unsigned int)base, prec, width, flags);
+}
+#endif  // PRINTF_SUPPORT_LONG_LONG
+
+#if defined(PRINTF_SUPPORT_FLOAT)
+
+#if defined(PRINTF_SUPPORT_EXPONENTIAL)
+// forward declaration so that _ftoa can switch to exp notation for values > PRINTF_MAX_FLOAT
+static size_t _etoa(out_fct_type out, char * buffer, size_t idx, size_t maxlen, double value, unsigned int prec,
+                    unsigned int width, unsigned int flags);
+#endif
+
+// internal ftoa for fixed decimal floating point
+static size_t _ftoa(out_fct_type out, char * buffer, size_t idx, size_t maxlen, double value, unsigned int prec,
+                    unsigned int width, unsigned int flags)
+{
+    char buf[PRINTF_FTOA_BUFFER_SIZE];
+    size_t len  = 0U;
+    double diff = 0.0;
+
+    // powers of 10
+    static const double pow10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 };
+
+    // test for special values
+    if(value != value)
+        return _out_rev(out, buffer, idx, maxlen, "nan", 3, width, flags);
+    if(value < -DBL_MAX)
+        return _out_rev(out, buffer, idx, maxlen, "fni-", 4, width, flags);
+    if(value > DBL_MAX)
+        return _out_rev(out, buffer, idx, maxlen, (flags & FLAGS_PLUS) ? "fni+" : "fni", (flags & FLAGS_PLUS) ? 4U : 3U, width,
+                        flags);
+
+    // test for very large values
+    // standard printf behavior is to print EVERY whole number digit -- which could be 100s of characters overflowing your buffers == bad
+    if((value > PRINTF_MAX_FLOAT) || (value < -PRINTF_MAX_FLOAT)) {
+#if defined(PRINTF_SUPPORT_EXPONENTIAL)
+        return _etoa(out, buffer, idx, maxlen, value, prec, width, flags);
+#else
+        return 0U;
+#endif
+    }
+
+    // test for negative
+    bool negative = false;
+    if(value < 0) {
+        negative = true;
+        value = 0 - value;
+    }
+
+    // set default precision, if not set explicitly
+    if(!(flags & FLAGS_PRECISION)) {
+        prec = PRINTF_DEFAULT_FLOAT_PRECISION;
+    }
+    // limit precision to 9, cause a prec >= 10 can lead to overflow errors
+    while((len < PRINTF_FTOA_BUFFER_SIZE) && (prec > 9U)) {
+        buf[len++] = '0';
+        prec--;
+    }
+
+    int whole = (int)value;
+    double tmp = (value - whole) * pow10[prec];
+    unsigned long frac = (unsigned long)tmp;
+    diff = tmp - frac;
+
+    if(diff > 0.5) {
+        ++frac;
+        // handle rollover, e.g. case 0.99 with prec 1 is 1.0
+        if(frac >= pow10[prec]) {
+            frac = 0;
+            ++whole;
+        }
+    }
+    else if(diff < 0.5) {
+    }
+    else if((frac == 0U) || (frac & 1U)) {
+        // if halfway, round up if odd OR if last digit is 0
+        ++frac;
+    }
+
+    if(prec == 0U) {
+        diff = value - (double)whole;
+        if((!(diff < 0.5) || (diff > 0.5)) && (whole & 1)) {
+            // exactly 0.5 and ODD, then round up
+            // 1.5 -> 2, but 2.5 -> 2
+            ++whole;
+        }
+    }
+    else {
+        unsigned int count = prec;
+        // now do fractional part, as an unsigned number
+        while(len < PRINTF_FTOA_BUFFER_SIZE) {
+            --count;
+            buf[len++] = (char)(48U + (frac % 10U));
+            if(!(frac /= 10U)) {
+                break;
+            }
+        }
+        // add extra 0s
+        while((len < PRINTF_FTOA_BUFFER_SIZE) && (count-- > 0U)) {
+            buf[len++] = '0';
+        }
+        if(len < PRINTF_FTOA_BUFFER_SIZE) {
+            // add decimal
+            buf[len++] = '.';
+        }
+    }
+
+    // do whole part, number is reversed
+    while(len < PRINTF_FTOA_BUFFER_SIZE) {
+        buf[len++] = (char)(48 + (whole % 10));
+        if(!(whole /= 10)) {
+            break;
+        }
+    }
+
+    // pad leading zeros
+    if(!(flags & FLAGS_LEFT) && (flags & FLAGS_ZEROPAD)) {
+        if(width && (negative || (flags & (FLAGS_PLUS | FLAGS_SPACE)))) {
+            width--;
+        }
+        while((len < width) && (len < PRINTF_FTOA_BUFFER_SIZE)) {
+            buf[len++] = '0';
+        }
+    }
+
+    if(len < PRINTF_FTOA_BUFFER_SIZE) {
+        if(negative) {
+            buf[len++] = '-';
+        }
+        else if(flags & FLAGS_PLUS) {
+            buf[len++] = '+';  // ignore the space if the '+' exists
+        }
+        else if(flags & FLAGS_SPACE) {
+            buf[len++] = ' ';
+        }
+    }
+
+    return _out_rev(out, buffer, idx, maxlen, buf, len, width, flags);
+}
+
+#if defined(PRINTF_SUPPORT_EXPONENTIAL)
+// internal ftoa variant for exponential floating-point type, contributed by Martijn Jasperse <m.jasperse@gmail.com>
+static size_t _etoa(out_fct_type out, char * buffer, size_t idx, size_t maxlen, double value, unsigned int prec,
+                    unsigned int width, unsigned int flags)
+{
+    // check for NaN and special values
+    if((value != value) || (value > DBL_MAX) || (value < -DBL_MAX)) {
+        return _ftoa(out, buffer, idx, maxlen, value, prec, width, flags);
+    }
+
+    // determine the sign
+    const bool negative = value < 0;
+    if(negative) {
+        value = -value;
+    }
+
+    // default precision
+    if(!(flags & FLAGS_PRECISION)) {
+        prec = PRINTF_DEFAULT_FLOAT_PRECISION;
+    }
+
+    // determine the decimal exponent
+    // based on the algorithm by David Gay (https://www.ampl.com/netlib/fp/dtoa.c)
+    union {
+        uint64_t U;
+        double   F;
+    } conv;
+
+    conv.F = value;
+    int exp2 = (int)((conv.U >> 52U) & 0x07FFU) - 1023;           // effectively log2
+    conv.U = (conv.U & ((1ULL << 52U) - 1U)) | (1023ULL << 52U);  // drop the exponent so conv.F is now in [1,2)
+    // now approximate log10 from the log2 integer part and an expansion of ln around 1.5
+    int expval = (int)(0.1760912590558 + exp2 * 0.301029995663981 + (conv.F - 1.5) * 0.289529654602168);
+    // now we want to compute 10^expval but we want to be sure it won't overflow
+    exp2 = (int)(expval * 3.321928094887362 + 0.5);
+    const double z  = expval * 2.302585092994046 - exp2 * 0.6931471805599453;
+    const double z2 = z * z;
+    conv.U = (uint64_t)(exp2 + 1023) << 52U;
+    // compute exp(z) using continued fractions, see https://en.wikipedia.org/wiki/Exponential_function#Continued_fractions_for_ex
+    conv.F *= 1 + 2 * z / (2 - z + (z2 / (6 + (z2 / (10 + z2 / 14)))));
+    // correct for rounding errors
+    if(value < conv.F) {
+        expval--;
+        conv.F /= 10;
+    }
+
+    // the exponent format is "%+03d" and largest value is "307", so set aside 4-5 characters
+    unsigned int minwidth = ((expval < 100) && (expval > -100)) ? 4U : 5U;
+
+    // in "%g" mode, "prec" is the number of *significant figures* not decimals
+    if(flags & FLAGS_ADAPT_EXP) {
+        // do we want to fall-back to "%f" mode?
+        if((value >= 1e-4) && (value < 1e6)) {
+            if((int)prec > expval) {
+                prec = (unsigned)((int)prec - expval - 1);
+            }
+            else {
+                prec = 0;
+            }
+            flags |= FLAGS_PRECISION;   // make sure _ftoa respects precision
+            // no characters in exponent
+            minwidth = 0U;
+            expval   = 0;
+        }
+        else {
+            // we use one sigfig for the whole part
+            if((prec > 0) && (flags & FLAGS_PRECISION)) {
+                --prec;
+            }
+        }
+    }
+
+    // will everything fit?
+    unsigned int fwidth = width;
+    if(width > minwidth) {
+        // we didn't fall-back so subtract the characters required for the exponent
+        fwidth -= minwidth;
+    }
+    else {
+        // not enough characters, so go back to default sizing
+        fwidth = 0U;
+    }
+    if((flags & FLAGS_LEFT) && minwidth) {
+        // if we're padding on the right, DON'T pad the floating part
+        fwidth = 0U;
+    }
+
+    // rescale the float value
+    if(expval) {
+        value /= conv.F;
+    }
+
+    // output the floating part
+    const size_t start_idx = idx;
+    idx = _ftoa(out, buffer, idx, maxlen, negative ? -value : value, prec, fwidth, flags & ~FLAGS_ADAPT_EXP);
+
+    // output the exponent part
+    if(minwidth) {
+        // output the exponential symbol
+        out((flags & FLAGS_UPPERCASE) ? 'E' : 'e', buffer, idx++, maxlen);
+        // output the exponent value
+        idx = _ntoa_long(out, buffer, idx, maxlen, (expval < 0) ? -expval : expval, expval < 0, 10, 0, minwidth - 1,
+                         FLAGS_ZEROPAD | FLAGS_PLUS);
+        // might need to right-pad spaces
+        if(flags & FLAGS_LEFT) {
+            while(idx - start_idx < width) out(' ', buffer, idx++, maxlen);
+        }
+    }
+    return idx;
+}
+#endif  // PRINTF_SUPPORT_EXPONENTIAL
+#endif  // PRINTF_SUPPORT_FLOAT
+
+// internal vsnprintf
+static int _lv_vsnprintf(out_fct_type out, char * buffer, const size_t maxlen, const char * format, va_list va)
+{
+    unsigned int flags, width, precision, n;
+    size_t idx = 0U;
+
+    if(!buffer) {
+        // use null output function
+        out = _out_null;
+    }
+
+    while(*format) {
+        // format specifier?  %[flags][width][.precision][length]
+        if(*format != '%') {
+            // no
+            out(*format, buffer, idx++, maxlen);
+            format++;
+            continue;
+        }
+        else {
+            // yes, evaluate it
+            format++;
+        }
+
+        // evaluate flags
+        flags = 0U;
+        do {
+            switch(*format) {
+                case '0':
+                    flags |= FLAGS_ZEROPAD;
+                    format++;
+                    n = 1U;
+                    break;
+                case '-':
+                    flags |= FLAGS_LEFT;
+                    format++;
+                    n = 1U;
+                    break;
+                case '+':
+                    flags |= FLAGS_PLUS;
+                    format++;
+                    n = 1U;
+                    break;
+                case ' ':
+                    flags |= FLAGS_SPACE;
+                    format++;
+                    n = 1U;
+                    break;
+                case '#':
+                    flags |= FLAGS_HASH;
+                    format++;
+                    n = 1U;
+                    break;
+                default :
+                    n = 0U;
+                    break;
+            }
+        } while(n);
+
+        // evaluate width field
+        width = 0U;
+        if(_is_digit(*format)) {
+            width = _atoi(&format);
+        }
+        else if(*format == '*') {
+            const int w = va_arg(va, int);
+            if(w < 0) {
+                flags |= FLAGS_LEFT;    // reverse padding
+                width = (unsigned int) - w;
+            }
+            else {
+                width = (unsigned int)w;
+            }
+            format++;
+        }
+
+        // evaluate precision field
+        precision = 0U;
+        if(*format == '.') {
+            flags |= FLAGS_PRECISION;
+            format++;
+            if(_is_digit(*format)) {
+                precision = _atoi(&format);
+            }
+            else if(*format == '*') {
+                const int prec = (int)va_arg(va, int);
+                precision = prec > 0 ? (unsigned int)prec : 0U;
+                format++;
+            }
+        }
+
+        // evaluate length field
+        switch(*format) {
+            case 'l' :
+                flags |= FLAGS_LONG;
+                format++;
+                if(*format == 'l') {
+                    flags |= FLAGS_LONG_LONG;
+                    format++;
+                }
+                break;
+            case 'h' :
+                flags |= FLAGS_SHORT;
+                format++;
+                if(*format == 'h') {
+                    flags |= FLAGS_CHAR;
+                    format++;
+                }
+                break;
+#if defined(PRINTF_SUPPORT_PTRDIFF_T)
+            case 't' :
+                flags |= (sizeof(ptrdiff_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG);
+                format++;
+                break;
+#endif
+            case 'j' :
+                flags |= (sizeof(intmax_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG);
+                format++;
+                break;
+            case 'z' :
+                flags |= (sizeof(size_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG);
+                format++;
+                break;
+            default :
+                break;
+        }
+
+        // evaluate specifier
+        switch(*format) {
+            case 'd' :
+            case 'i' :
+            case 'u' :
+            case 'x' :
+            case 'X' :
+            case 'p' :
+            case 'P' :
+            case 'o' :
+            case 'b' : {
+                    // set the base
+                    unsigned int base;
+                    if(*format == 'x' || *format == 'X') {
+                        base = 16U;
+                    }
+                    else if(*format == 'p' || *format == 'P') {
+                        base = 16U;
+                        flags |= FLAGS_HASH;   // always hash for pointer format
+#if defined(PRINTF_SUPPORT_LONG_LONG)
+                        if(sizeof(uintptr_t) == sizeof(long long))
+                            flags |= FLAGS_LONG_LONG;
+                        else
+#endif
+                            flags |= FLAGS_LONG;
+
+                        if(*(format + 1) == 'V')
+                            format++;
+                    }
+                    else if(*format == 'o') {
+                        base =  8U;
+                    }
+                    else if(*format == 'b') {
+                        base =  2U;
+                    }
+                    else {
+                        base = 10U;
+                        flags &= ~FLAGS_HASH;   // no hash for dec format
+                    }
+                    // uppercase
+                    if(*format == 'X' || *format == 'P') {
+                        flags |= FLAGS_UPPERCASE;
+                    }
+
+                    // no plus or space flag for u, x, X, o, b
+                    if((*format != 'i') && (*format != 'd')) {
+                        flags &= ~(FLAGS_PLUS | FLAGS_SPACE);
+                    }
+
+                    // ignore '0' flag when precision is given
+                    if(flags & FLAGS_PRECISION) {
+                        flags &= ~FLAGS_ZEROPAD;
+                    }
+
+                    // convert the integer
+                    if((*format == 'i') || (*format == 'd')) {
+                        // signed
+                        if(flags & FLAGS_LONG_LONG) {
+#if defined(PRINTF_SUPPORT_LONG_LONG)
+                            const long long value = va_arg(va, long long);
+                            idx = _ntoa_long_long(out, buffer, idx, maxlen, (unsigned long long)(value > 0 ? value : 0 - value), value < 0, base,
+                                                  precision, width, flags);
+#endif
+                        }
+                        else if(flags & FLAGS_LONG) {
+                            const long value = va_arg(va, long);
+                            idx = _ntoa_long(out, buffer, idx, maxlen, (unsigned long)(value > 0 ? value : 0 - value), value < 0, base, precision,
+                                             width, flags);
+                        }
+                        else {
+                            const int value = (flags & FLAGS_CHAR) ? (char)va_arg(va, int) : (flags & FLAGS_SHORT) ? (short int)va_arg(va,
+                                                                                                                                       int) : va_arg(va, int);
+                            idx = _ntoa_long(out, buffer, idx, maxlen, (unsigned int)(value > 0 ? value : 0 - value), value < 0, base, precision,
+                                             width, flags);
+                        }
+                    }
+                    else if(*format == 'V') {
+                        lv_vaformat_t * vaf = va_arg(va, lv_vaformat_t *);
+                        va_list copy;
+
+                        va_copy(copy, *vaf->va);
+                        idx += _lv_vsnprintf(out, buffer + idx, maxlen - idx, vaf->fmt, copy);
+                        va_end(copy);
+                    }
+                    else {
+                        // unsigned
+                        if(flags & FLAGS_LONG_LONG) {
+#if defined(PRINTF_SUPPORT_LONG_LONG)
+                            idx = _ntoa_long_long(out, buffer, idx, maxlen, va_arg(va, unsigned long long), false, base, precision, width, flags);
+#endif
+                        }
+                        else if(flags & FLAGS_LONG) {
+                            idx = _ntoa_long(out, buffer, idx, maxlen, va_arg(va, unsigned long), false, base, precision, width, flags);
+                        }
+                        else {
+                            const unsigned int value = (flags & FLAGS_CHAR) ? (unsigned char)va_arg(va,
+                                                                                                    unsigned int) : (flags & FLAGS_SHORT) ? (unsigned short int)va_arg(va, unsigned int) : va_arg(va, unsigned int);
+                            idx = _ntoa_long(out, buffer, idx, maxlen, value, false, base, precision, width, flags);
+                        }
+                    }
+                    format++;
+                    break;
+                }
+#if defined(PRINTF_SUPPORT_FLOAT)
+            case 'f' :
+            case 'F' :
+                if(*format == 'F') flags |= FLAGS_UPPERCASE;
+                idx = _ftoa(out, buffer, idx, maxlen, va_arg(va, double), precision, width, flags);
+                format++;
+                break;
+#if defined(PRINTF_SUPPORT_EXPONENTIAL)
+            case 'e':
+            case 'E':
+            case 'g':
+            case 'G':
+                if((*format == 'g') || (*format == 'G')) flags |= FLAGS_ADAPT_EXP;
+                if((*format == 'E') || (*format == 'G')) flags |= FLAGS_UPPERCASE;
+                idx = _etoa(out, buffer, idx, maxlen, va_arg(va, double), precision, width, flags);
+                format++;
+                break;
+#endif  // PRINTF_SUPPORT_EXPONENTIAL
+#endif  // PRINTF_SUPPORT_FLOAT
+            case 'c' : {
+                    unsigned int l = 1U;
+                    // pre padding
+                    if(!(flags & FLAGS_LEFT)) {
+                        while(l++ < width) {
+                            out(' ', buffer, idx++, maxlen);
+                        }
+                    }
+                    // char output
+                    out((char)va_arg(va, int), buffer, idx++, maxlen);
+                    // post padding
+                    if(flags & FLAGS_LEFT) {
+                        while(l++ < width) {
+                            out(' ', buffer, idx++, maxlen);
+                        }
+                    }
+                    format++;
+                    break;
+                }
+
+            case 's' : {
+                    const char * p = va_arg(va, char *);
+                    unsigned int l = _strnlen_s(p, precision ? precision : (size_t) -1);
+                    // pre padding
+                    if(flags & FLAGS_PRECISION) {
+                        l = (l < precision ? l : precision);
+                    }
+                    if(!(flags & FLAGS_LEFT)) {
+                        while(l++ < width) {
+                            out(' ', buffer, idx++, maxlen);
+                        }
+                    }
+                    // string output
+                    while((*p != 0) && (!(flags & FLAGS_PRECISION) || precision--)) {
+                        out(*(p++), buffer, idx++, maxlen);
+                    }
+                    // post padding
+                    if(flags & FLAGS_LEFT) {
+                        while(l++ < width) {
+                            out(' ', buffer, idx++, maxlen);
+                        }
+                    }
+                    format++;
+                    break;
+                }
+
+            case '%' :
+                out('%', buffer, idx++, maxlen);
+                format++;
+                break;
+
+            default :
+                out(*format, buffer, idx++, maxlen);
+                format++;
+                break;
+        }
+    }
+
+    // termination
+    out((char)0, buffer, idx < maxlen ? idx : maxlen - 1U, maxlen);
+
+    // return written chars without terminating \0
+    return (int)idx;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// GLOBAL FUNCTIONS FOR LVGL
+///////////////////////////////////////////////////////////////////////////////
+
+int lv_snprintf(char * buffer, size_t count, const char * format, ...)
+{
+    va_list va;
+    va_start(va, format);
+    const int ret = _lv_vsnprintf(_out_buffer, buffer, count, format, va);
+    va_end(va);
+    return ret;
+}
+
+int lv_vsnprintf(char * buffer, size_t count, const char * format, va_list va)
+{
+    return _lv_vsnprintf(_out_buffer, buffer, count, format, va);
+}
+
+#endif /*LV_STDLIB_BUILTIN*/
diff --git a/lib/lvgl/src/stdlib/builtin/lv_string_builtin.c b/lib/lvgl/src/stdlib/builtin/lv_string_builtin.c
new file mode 100644
index 00000000..a033a78b
--- /dev/null
+++ b/lib/lvgl/src/stdlib/builtin/lv_string_builtin.c
@@ -0,0 +1,223 @@
+/**
+ * @file lv_string.c
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../../lv_conf_internal.h"
+#if LV_USE_STDLIB_STRING == LV_STDLIB_BUILTIN
+#include "../../misc/lv_assert.h"
+#include "../../misc/lv_log.h"
+#include "../../misc/lv_math.h"
+#include "../../stdlib/lv_string.h"
+#include "../../stdlib/lv_mem.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#ifdef LV_ARCH_64
+    #define MEM_UNIT         uint64_t
+    #define ALIGN_MASK       0x7
+#else
+    #define MEM_UNIT         uint32_t
+    #define ALIGN_MASK       0x3
+#endif
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+#if LV_USE_LOG && LV_LOG_TRACE_MEM
+    #define LV_TRACE_MEM(...) LV_LOG_TRACE(__VA_ARGS__)
+#else
+    #define LV_TRACE_MEM(...)
+#endif
+
+#define _COPY(d, s) *d = *s; d++; s++;
+#define _SET(d, v) *d = v; d++;
+#define _REPEAT8(expr) expr expr expr expr expr expr expr expr
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void * LV_ATTRIBUTE_FAST_MEM lv_memcpy(void * dst, const void * src, size_t len)
+{
+    uint8_t * d8 = dst;
+    const uint8_t * s8 = src;
+
+    /*Simplify for small memories*/
+    if(len < 16) {
+        while(len) {
+            *d8 = *s8;
+            d8++;
+            s8++;
+            len--;
+        }
+        return dst;
+    }
+
+    lv_uintptr_t d_align = (lv_uintptr_t)d8 & ALIGN_MASK;
+    lv_uintptr_t s_align = (lv_uintptr_t)s8 & ALIGN_MASK;
+
+    /*Byte copy for unaligned memories*/
+    if(s_align != d_align) {
+        while(len > 32) {
+            _REPEAT8(_COPY(d8, s8));
+            _REPEAT8(_COPY(d8, s8));
+            _REPEAT8(_COPY(d8, s8));
+            _REPEAT8(_COPY(d8, s8));
+            len -= 32;
+        }
+        while(len) {
+            _COPY(d8, s8)
+            len--;
+        }
+        return dst;
+    }
+
+    /*Make the memories aligned*/
+    if(d_align) {
+        d_align = ALIGN_MASK + 1 - d_align;
+        while(d_align && len) {
+            _COPY(d8, s8);
+            d_align--;
+            len--;
+        }
+    }
+
+    uint32_t * d32 = (uint32_t *)d8;
+    const uint32_t * s32 = (uint32_t *)s8;
+    while(len > 32) {
+        _REPEAT8(_COPY(d32, s32))
+        len -= 32;
+    }
+
+    d8 = (uint8_t *)d32;
+    s8 = (const uint8_t *)s32;
+    while(len) {
+        _COPY(d8, s8)
+        len--;
+    }
+
+    return dst;
+}
+
+void LV_ATTRIBUTE_FAST_MEM lv_memset(void * dst, uint8_t v, size_t len)
+{
+    uint8_t * d8 = (uint8_t *)dst;
+    uintptr_t d_align = (lv_uintptr_t) d8 & ALIGN_MASK;
+
+    /*Make the address aligned*/
+    if(d_align) {
+        d_align = ALIGN_MASK + 1 - d_align;
+        while(d_align && len) {
+            _SET(d8, v);
+            len--;
+            d_align--;
+        }
+    }
+
+    uint32_t v32 = (uint32_t)v + ((uint32_t)v << 8) + ((uint32_t)v << 16) + ((uint32_t)v << 24);
+    uint32_t * d32 = (uint32_t *)d8;
+
+    while(len > 32) {
+        _REPEAT8(_SET(d32, v32));
+        len -= 32;
+    }
+
+    d8 = (uint8_t *)d32;
+    while(len) {
+        _SET(d8, v);
+        len--;
+    }
+}
+
+void * LV_ATTRIBUTE_FAST_MEM lv_memmove(void * dst, const void * src, size_t len)
+{
+    if(dst < src || (char *)dst > ((char *)src + len)) {
+        return lv_memcpy(dst, src, len);
+    }
+
+    if(dst > src) {
+        char * tmp = (char *)dst + len - 1;
+        char * s   = (char *)src + len - 1;
+
+        while(len--) {
+            *tmp-- = *s--;
+        }
+    }
+    else {
+        char * tmp = (char *)dst;
+        char * s   = (char *)src;
+
+        while(len--) {
+            *tmp++ = *s++;
+        }
+    }
+
+    return dst;
+}
+
+/* See https://en.cppreference.com/w/c/string/byte/strlen for reference */
+size_t lv_strlen(const char * str)
+{
+    size_t i = 0;
+    while(str[i]) i++;
+
+    return i;
+}
+
+char * lv_strncpy(char * dst, const char * src, size_t dst_size)
+{
+    size_t i;
+    for(i = 0; i < dst_size - 1 && src[i]; i++) {
+        dst[i] = src[i];
+    }
+    dst[i] = '\0';
+    return dst;
+}
+
+char * lv_strcpy(char * dst, const char * src)
+{
+    char * tmp = dst;
+    while((*dst++ = *src++) != '\0');
+    return tmp;
+}
+
+int32_t lv_strcmp(const char * s1, const char * s2)
+{
+    while(*s1 && (*s1 == *s2)) {
+        s1++;
+        s2++;
+    }
+    return *(const unsigned char *)s1 - *(const unsigned char *)s2;
+}
+
+char * lv_strdup(const char * src)
+{
+    size_t len = lv_strlen(src) + 1;
+    char * dst = lv_malloc(len);
+    if(dst == NULL) return NULL;
+
+    lv_memcpy(dst, src, len); /*do memcpy is faster than strncpy when length is known*/
+    return dst;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+#endif /*LV_STDLIB_BUILTIN*/
diff --git a/lib/lvgl/src/stdlib/builtin/lv_tlsf.c b/lib/lvgl/src/stdlib/builtin/lv_tlsf.c
new file mode 100644
index 00000000..8910b05e
--- /dev/null
+++ b/lib/lvgl/src/stdlib/builtin/lv_tlsf.c
@@ -0,0 +1,1245 @@
+#include "../../lv_conf_internal.h"
+#if LV_USE_STDLIB_MALLOC == LV_STDLIB_BUILTIN
+
+#include <limits.h>
+#include "lv_tlsf.h"
+#include "../../stdlib/lv_string.h"
+#include "../../misc/lv_log.h"
+#include "../../misc/lv_assert.h"
+
+#undef  printf
+#define printf LV_LOG_ERROR
+
+#define TLSF_MAX_POOL_SIZE (LV_MEM_SIZE + LV_MEM_POOL_EXPAND_SIZE)
+
+#if !defined(_DEBUG)
+    #define _DEBUG 0
+#endif
+
+#if defined(__cplusplus)
+    #define tlsf_decl inline
+#else
+    #define tlsf_decl static
+#endif
+
+/*
+** Architecture-specific bit manipulation routines.
+**
+** TLSF achieves O(1) cost for malloc and free operations by limiting
+** the search for a free block to a free list of guaranteed size
+** adequate to fulfill the request, combined with efficient free list
+** queries using bitmasks and architecture-specific bit-manipulation
+** routines.
+**
+** Most modern processors provide instructions to count leading zeroes
+** in a word, find the lowest and highest set bit, etc. These
+** specific implementations will be used when available, falling back
+** to a reasonably efficient generic implementation.
+**
+** NOTE: TLSF spec relies on ffs/fls returning value 0..31.
+** ffs/fls return 1-32 by default, returning 0 for error.
+*/
+
+/*
+** Detect whether or not we are building for a 32- or 64-bit (LP/LLP)
+** architecture. There is no reliable portable method at compile-time.
+*/
+#if defined (__alpha__) || defined (__ia64__) || defined (__x86_64__) \
+    || defined (_WIN64) || defined (__LP64__) || defined (__LLP64__)
+    #define TLSF_64BIT
+#endif
+
+/*
+** Returns one plus the index of the most significant 1-bit of n,
+** or if n is zero, returns zero.
+*/
+#ifdef TLSF_64BIT
+    #define TLSF_FLS(n) ((n) & 0xffffffff00000000ull ? 32 + TLSF_FLS32((size_t)(n) >> 32) : TLSF_FLS32(n))
+#else
+    #define TLSF_FLS(n) TLSF_FLS32(n)
+#endif
+
+#define TLSF_FLS32(n) ((n) & 0xffff0000 ? 16 + TLSF_FLS16((n) >> 16) : TLSF_FLS16(n))
+#define TLSF_FLS16(n) ((n) & 0xff00     ?  8 + TLSF_FLS8 ((n) >>  8) : TLSF_FLS8 (n))
+#define TLSF_FLS8(n)  ((n) & 0xf0       ?  4 + TLSF_FLS4 ((n) >>  4) : TLSF_FLS4 (n))
+#define TLSF_FLS4(n)  ((n) & 0xc        ?  2 + TLSF_FLS2 ((n) >>  2) : TLSF_FLS2 (n))
+#define TLSF_FLS2(n)  ((n) & 0x2        ?  1 + TLSF_FLS1 ((n) >>  1) : TLSF_FLS1 (n))
+#define TLSF_FLS1(n)  ((n) & 0x1        ?  1 : 0)
+
+/*
+** Returns round up value of log2(n).
+** Note: it is used at compile time.
+*/
+#define TLSF_LOG2_CEIL(n) ((n) & (n - 1) ? TLSF_FLS(n) : TLSF_FLS(n) - 1)
+
+/*
+** gcc 3.4 and above have builtin support, specialized for architecture.
+** Some compilers masquerade as gcc; patchlevel test filters them out.
+*/
+#if defined (__GNUC__) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) \
+    && defined (__GNUC_PATCHLEVEL__)
+
+#if defined (__SNC__)
+/* SNC for Playstation 3. */
+
+tlsf_decl int tlsf_ffs(unsigned int word)
+{
+    const unsigned int reverse = word & (~word + 1);
+    const int bit = 32 - __builtin_clz(reverse);
+    return bit - 1;
+}
+
+#else
+
+tlsf_decl int tlsf_ffs(unsigned int word)
+{
+    return __builtin_ffs(word) - 1;
+}
+
+#endif
+
+tlsf_decl int tlsf_fls(unsigned int word)
+{
+    const int bit = word ? 32 - __builtin_clz(word) : 0;
+    return bit - 1;
+}
+
+#elif defined (_MSC_VER) && (_MSC_VER >= 1400) && (defined (_M_IX86) || defined (_M_X64))
+/* Microsoft Visual C++ support on x86/X64 architectures. */
+
+#include <intrin.h>
+
+#pragma intrinsic(_BitScanReverse)
+#pragma intrinsic(_BitScanForward)
+
+tlsf_decl int tlsf_fls(unsigned int word)
+{
+    unsigned long index;
+    return _BitScanReverse(&index, word) ? index : -1;
+}
+
+tlsf_decl int tlsf_ffs(unsigned int word)
+{
+    unsigned long index;
+    return _BitScanForward(&index, word) ? index : -1;
+}
+
+#elif defined (_MSC_VER) && defined (_M_PPC)
+/* Microsoft Visual C++ support on PowerPC architectures. */
+
+#include <ppcintrinsics.h>
+
+tlsf_decl int tlsf_fls(unsigned int word)
+{
+    const int bit = 32 - _CountLeadingZeros(word);
+    return bit - 1;
+}
+
+tlsf_decl int tlsf_ffs(unsigned int word)
+{
+    const unsigned int reverse = word & (~word + 1);
+    const int bit = 32 - _CountLeadingZeros(reverse);
+    return bit - 1;
+}
+
+#elif defined (__ARMCC_VERSION)
+/* RealView Compilation Tools for ARM */
+
+tlsf_decl int tlsf_ffs(unsigned int word)
+{
+    const unsigned int reverse = word & (~word + 1);
+    const int bit = 32 - __clz(reverse);
+    return bit - 1;
+}
+
+tlsf_decl int tlsf_fls(unsigned int word)
+{
+    const int bit = word ? 32 - __clz(word) : 0;
+    return bit - 1;
+}
+
+#elif defined (__ghs__)
+/* Green Hills support for PowerPC */
+
+#include <ppc_ghs.h>
+
+tlsf_decl int tlsf_ffs(unsigned int word)
+{
+    const unsigned int reverse = word & (~word + 1);
+    const int bit = 32 - __CLZ32(reverse);
+    return bit - 1;
+}
+
+tlsf_decl int tlsf_fls(unsigned int word)
+{
+    const int bit = word ? 32 - __CLZ32(word) : 0;
+    return bit - 1;
+}
+
+#else
+/* Fall back to generic implementation. */
+
+/* Implement ffs in terms of fls. */
+tlsf_decl int tlsf_ffs(unsigned int word)
+{
+    const unsigned int reverse = word & (~word + 1);
+    return TLSF_FLS32(reverse) - 1;
+}
+
+tlsf_decl int tlsf_fls(unsigned int word)
+{
+    return TLSF_FLS32(word) - 1;
+}
+
+#endif
+
+/* Possibly 64-bit version of tlsf_fls. */
+#if defined (TLSF_64BIT)
+tlsf_decl int tlsf_fls_sizet(size_t size)
+{
+    int high = (int)(size >> 32);
+    int bits = 0;
+    if(high) {
+        bits = 32 + tlsf_fls(high);
+    }
+    else {
+        bits = tlsf_fls((int)size & 0xffffffff);
+
+    }
+    return bits;
+}
+#else
+#define tlsf_fls_sizet tlsf_fls
+#endif
+
+#undef tlsf_decl
+
+/*
+** Constants.
+*/
+
+/* Public constants: may be modified. */
+enum tlsf_public {
+    /* log2 of number of linear subdivisions of block sizes. Larger
+    ** values require more memory in the control structure. Values of
+    ** 4 or 5 are typical.
+    */
+    SL_INDEX_COUNT_LOG2 = 5,
+};
+
+/* Private constants: do not modify. */
+enum tlsf_private {
+#if defined (TLSF_64BIT)
+    /* All allocation sizes and addresses are aligned to 8 bytes. */
+    ALIGN_SIZE_LOG2 = 3,
+#else
+    /* All allocation sizes and addresses are aligned to 4 bytes. */
+    ALIGN_SIZE_LOG2 = 2,
+#endif
+    ALIGN_SIZE = (1 << ALIGN_SIZE_LOG2),
+
+    /*
+    ** We support allocations of sizes up to (1 << FL_INDEX_MAX) bits.
+    ** However, because we linearly subdivide the second-level lists, and
+    ** our minimum size granularity is 4 bytes, it doesn't make sense to
+    ** create first-level lists for sizes smaller than SL_INDEX_COUNT * 4,
+    ** or (1 << (SL_INDEX_COUNT_LOG2 + 2)) bytes, as there we will be
+    ** trying to split size ranges into more slots than we have available.
+    ** Instead, we calculate the minimum threshold size, and place all
+    ** blocks below that size into the 0th first-level list.
+    */
+
+#if defined (TLSF_MAX_POOL_SIZE)
+    FL_INDEX_MAX = TLSF_LOG2_CEIL(TLSF_MAX_POOL_SIZE),
+#elif defined (TLSF_64BIT)
+    /*
+    ** TODO: We can increase this to support larger sizes, at the expense
+    ** of more overhead in the TLSF structure.
+    */
+    FL_INDEX_MAX = 32,
+#else
+    FL_INDEX_MAX = 30,
+#endif
+    SL_INDEX_COUNT = (1 << SL_INDEX_COUNT_LOG2),
+    FL_INDEX_SHIFT = (SL_INDEX_COUNT_LOG2 + ALIGN_SIZE_LOG2),
+    FL_INDEX_COUNT = (FL_INDEX_MAX - FL_INDEX_SHIFT + 1),
+
+    SMALL_BLOCK_SIZE = (1 << FL_INDEX_SHIFT),
+};
+
+/*
+** Cast and min/max macros.
+*/
+
+#define tlsf_cast(t, exp)   ((t) (exp))
+#define tlsf_min(a, b)      ((a) < (b) ? (a) : (b))
+#define tlsf_max(a, b)      ((a) > (b) ? (a) : (b))
+
+/*
+** Set assert macro, if it has not been provided by the user.
+*/
+#define tlsf_assert LV_ASSERT
+
+#if !defined (tlsf_assert)
+    #define tlsf_assert assert
+#endif
+
+/*
+** Static assertion mechanism.
+*/
+
+#define _tlsf_glue2(x, y) x ## y
+#define _tlsf_glue(x, y) _tlsf_glue2(x, y)
+#define tlsf_static_assert(exp) \
+    typedef char _tlsf_glue(static_assert, __LINE__) [(exp) ? 1 : -1]
+
+/* This code has been tested on 32- and 64-bit (LP/LLP) architectures. */
+tlsf_static_assert(sizeof(int) * CHAR_BIT == 32);
+tlsf_static_assert(sizeof(size_t) * CHAR_BIT >= 32);
+tlsf_static_assert(sizeof(size_t) * CHAR_BIT <= 64);
+
+/* SL_INDEX_COUNT must be <= number of bits in sl_bitmap's storage type. */
+tlsf_static_assert(sizeof(unsigned int) * CHAR_BIT >= SL_INDEX_COUNT);
+
+/* Ensure we've properly tuned our sizes. */
+tlsf_static_assert(ALIGN_SIZE == SMALL_BLOCK_SIZE / SL_INDEX_COUNT);
+
+/*
+** Data structures and associated constants.
+*/
+
+/*
+** Block header structure.
+**
+** There are several implementation subtleties involved:
+** - The prev_phys_block field is only valid if the previous block is free.
+** - The prev_phys_block field is actually stored at the end of the
+**   previous block. It appears at the beginning of this structure only to
+**   simplify the implementation.
+** - The next_free / prev_free fields are only valid if the block is free.
+*/
+typedef struct block_header_t {
+    /* Points to the previous physical block. */
+    struct block_header_t * prev_phys_block;
+
+    /* The size of this block, excluding the block header. */
+    size_t size;
+
+    /* Next and previous free blocks. */
+    struct block_header_t * next_free;
+    struct block_header_t * prev_free;
+} block_header_t;
+
+/*
+** Since block sizes are always at least a multiple of 4, the two least
+** significant bits of the size field are used to store the block status:
+** - bit 0: whether block is busy or free
+** - bit 1: whether previous block is busy or free
+*/
+static const size_t block_header_free_bit = 1 << 0;
+static const size_t block_header_prev_free_bit = 1 << 1;
+
+/*
+** The size of the block header exposed to used blocks is the size field.
+** The prev_phys_block field is stored *inside* the previous free block.
+*/
+static const size_t block_header_overhead = sizeof(size_t);
+
+/* User data starts directly after the size field in a used block. */
+static const size_t block_start_offset =
+    offsetof(block_header_t, size) + sizeof(size_t);
+
+/*
+** A free block must be large enough to store its header minus the size of
+** the prev_phys_block field, and no larger than the number of addressable
+** bits for FL_INDEX.
+*/
+static const size_t block_size_min =
+    sizeof(block_header_t) - sizeof(block_header_t *);
+static const size_t block_size_max = tlsf_cast(size_t, 1) << FL_INDEX_MAX;
+
+/* The TLSF control structure. */
+typedef struct control_t {
+    /* Empty lists point at this block to indicate they are free. */
+    block_header_t block_null;
+
+    /* Bitmaps for free lists. */
+    unsigned int fl_bitmap;
+    unsigned int sl_bitmap[FL_INDEX_COUNT];
+
+    /* Head of free lists. */
+    block_header_t * blocks[FL_INDEX_COUNT][SL_INDEX_COUNT];
+} control_t;
+
+/* A type used for casting when doing pointer arithmetic. */
+typedef ptrdiff_t tlsfptr_t;
+
+/*
+** block_header_t member functions.
+*/
+
+static size_t block_size(const block_header_t * block)
+{
+    return block->size & ~(block_header_free_bit | block_header_prev_free_bit);
+}
+
+static void block_set_size(block_header_t * block, size_t size)
+{
+    const size_t oldsize = block->size;
+    block->size = size | (oldsize & (block_header_free_bit | block_header_prev_free_bit));
+}
+
+static int block_is_last(const block_header_t * block)
+{
+    return block_size(block) == 0;
+}
+
+static int block_is_free(const block_header_t * block)
+{
+    return tlsf_cast(int, block->size & block_header_free_bit);
+}
+
+static void block_set_free(block_header_t * block)
+{
+    block->size |= block_header_free_bit;
+}
+
+static void block_set_used(block_header_t * block)
+{
+    block->size &= ~block_header_free_bit;
+}
+
+static int block_is_prev_free(const block_header_t * block)
+{
+    return tlsf_cast(int, block->size & block_header_prev_free_bit);
+}
+
+static void block_set_prev_free(block_header_t * block)
+{
+    block->size |= block_header_prev_free_bit;
+}
+
+static void block_set_prev_used(block_header_t * block)
+{
+    block->size &= ~block_header_prev_free_bit;
+}
+
+static block_header_t * block_from_ptr(const void * ptr)
+{
+    return tlsf_cast(block_header_t *,
+                     tlsf_cast(unsigned char *, ptr) - block_start_offset);
+}
+
+static void * block_to_ptr(const block_header_t * block)
+{
+    return tlsf_cast(void *,
+                     tlsf_cast(unsigned char *, block) + block_start_offset);
+}
+
+/* Return location of next block after block of given size. */
+static block_header_t * offset_to_block(const void * ptr, size_t size)
+{
+    return tlsf_cast(block_header_t *, tlsf_cast(tlsfptr_t, ptr) + size);
+}
+
+/* Return location of previous block. */
+static block_header_t * block_prev(const block_header_t * block)
+{
+    tlsf_assert(block_is_prev_free(block) && "previous block must be free");
+    return block->prev_phys_block;
+}
+
+/* Return location of next existing block. */
+static block_header_t * block_next(const block_header_t * block)
+{
+    block_header_t * next = offset_to_block(block_to_ptr(block),
+                                            block_size(block) - block_header_overhead);
+    tlsf_assert(!block_is_last(block));
+    return next;
+}
+
+/* Link a new block with its physical neighbor, return the neighbor. */
+static block_header_t * block_link_next(block_header_t * block)
+{
+    block_header_t * next = block_next(block);
+    next->prev_phys_block = block;
+    return next;
+}
+
+static void block_mark_as_free(block_header_t * block)
+{
+    /* Link the block to the next block, first. */
+    block_header_t * next = block_link_next(block);
+    block_set_prev_free(next);
+    block_set_free(block);
+}
+
+static void block_mark_as_used(block_header_t * block)
+{
+    block_header_t * next = block_next(block);
+    block_set_prev_used(next);
+    block_set_used(block);
+}
+
+static size_t align_up(size_t x, size_t align)
+{
+    tlsf_assert(0 == (align & (align - 1)) && "must align to a power of two");
+    return (x + (align - 1)) & ~(align - 1);
+}
+
+static size_t align_down(size_t x, size_t align)
+{
+    tlsf_assert(0 == (align & (align - 1)) && "must align to a power of two");
+    return x - (x & (align - 1));
+}
+
+static void * align_ptr(const void * ptr, size_t align)
+{
+    const tlsfptr_t aligned =
+        (tlsf_cast(tlsfptr_t, ptr) + (align - 1)) & ~(align - 1);
+    tlsf_assert(0 == (align & (align - 1)) && "must align to a power of two");
+    return tlsf_cast(void *, aligned);
+}
+
+/*
+** Adjust an allocation size to be aligned to word size, and no smaller
+** than internal minimum.
+*/
+static size_t adjust_request_size(size_t size, size_t align)
+{
+    size_t adjust = 0;
+    if(size) {
+        const size_t aligned = align_up(size, align);
+
+        /* aligned sized must not exceed block_size_max or we'll go out of bounds on sl_bitmap */
+        if(aligned < block_size_max) {
+            adjust = tlsf_max(aligned, block_size_min);
+        }
+    }
+    return adjust;
+}
+
+/*
+** TLSF utility functions. In most cases, these are direct translations of
+** the documentation found in the white paper.
+*/
+
+static void mapping_insert(size_t size, int * fli, int * sli)
+{
+    int fl, sl;
+    if(size < SMALL_BLOCK_SIZE) {
+        /* Store small blocks in first list. */
+        fl = 0;
+        sl = tlsf_cast(int, size) / (SMALL_BLOCK_SIZE / SL_INDEX_COUNT);
+    }
+    else {
+        fl = tlsf_fls_sizet(size);
+        sl = tlsf_cast(int, size >> (fl - SL_INDEX_COUNT_LOG2)) ^ (1 << SL_INDEX_COUNT_LOG2);
+        fl -= (FL_INDEX_SHIFT - 1);
+    }
+    *fli = fl;
+    *sli = sl;
+}
+
+/* This version rounds up to the next block size (for allocations) */
+static void mapping_search(size_t size, int * fli, int * sli)
+{
+    if(size >= SMALL_BLOCK_SIZE) {
+        const size_t round = (1 << (tlsf_fls_sizet(size) - SL_INDEX_COUNT_LOG2)) - 1;
+        size += round;
+    }
+    mapping_insert(size, fli, sli);
+}
+
+static block_header_t * search_suitable_block(control_t * control, int * fli, int * sli)
+{
+    int fl = *fli;
+    int sl = *sli;
+
+    /*
+    ** First, search for a block in the list associated with the given
+    ** fl/sl index.
+    */
+    unsigned int sl_map = control->sl_bitmap[fl] & (~0U << sl);
+    if(!sl_map) {
+        /* No block exists. Search in the next largest first-level list. */
+        const unsigned int fl_map = control->fl_bitmap & (~0U << (fl + 1));
+        if(!fl_map) {
+            /* No free blocks available, memory has been exhausted. */
+            return 0;
+        }
+
+        fl = tlsf_ffs(fl_map);
+        *fli = fl;
+        sl_map = control->sl_bitmap[fl];
+    }
+    tlsf_assert(sl_map && "internal error - second level bitmap is null");
+    sl = tlsf_ffs(sl_map);
+    *sli = sl;
+
+    /* Return the first block in the free list. */
+    return control->blocks[fl][sl];
+}
+
+/* Remove a free block from the free list.*/
+static void remove_free_block(control_t * control, block_header_t * block, int fl, int sl)
+{
+    block_header_t * prev = block->prev_free;
+    block_header_t * next = block->next_free;
+    tlsf_assert(prev && "prev_free field can not be null");
+    tlsf_assert(next && "next_free field can not be null");
+    next->prev_free = prev;
+    prev->next_free = next;
+
+    /* If this block is the head of the free list, set new head. */
+    if(control->blocks[fl][sl] == block) {
+        control->blocks[fl][sl] = next;
+
+        /* If the new head is null, clear the bitmap. */
+        if(next == &control->block_null) {
+            control->sl_bitmap[fl] &= ~(1U << sl);
+
+            /* If the second bitmap is now empty, clear the fl bitmap. */
+            if(!control->sl_bitmap[fl]) {
+                control->fl_bitmap &= ~(1U << fl);
+            }
+        }
+    }
+}
+
+/* Insert a free block into the free block list. */
+static void insert_free_block(control_t * control, block_header_t * block, int fl, int sl)
+{
+    block_header_t * current = control->blocks[fl][sl];
+    tlsf_assert(current && "free list cannot have a null entry");
+    tlsf_assert(block && "cannot insert a null entry into the free list");
+    block->next_free = current;
+    block->prev_free = &control->block_null;
+    current->prev_free = block;
+
+    tlsf_assert(block_to_ptr(block) == align_ptr(block_to_ptr(block), ALIGN_SIZE)
+                && "block not aligned properly");
+    /*
+    ** Insert the new block at the head of the list, and mark the first-
+    ** and second-level bitmaps appropriately.
+    */
+    control->blocks[fl][sl] = block;
+    control->fl_bitmap |= (1U << fl);
+    control->sl_bitmap[fl] |= (1U << sl);
+}
+
+/* Remove a given block from the free list. */
+static void block_remove(control_t * control, block_header_t * block)
+{
+    int fl, sl;
+    mapping_insert(block_size(block), &fl, &sl);
+    remove_free_block(control, block, fl, sl);
+}
+
+/* Insert a given block into the free list. */
+static void block_insert(control_t * control, block_header_t * block)
+{
+    int fl, sl;
+    mapping_insert(block_size(block), &fl, &sl);
+    insert_free_block(control, block, fl, sl);
+}
+
+static int block_can_split(block_header_t * block, size_t size)
+{
+    return block_size(block) >= sizeof(block_header_t) + size;
+}
+
+/* Split a block into two, the second of which is free. */
+static block_header_t * block_split(block_header_t * block, size_t size)
+{
+    /* Calculate the amount of space left in the remaining block. */
+    block_header_t * remaining =
+        offset_to_block(block_to_ptr(block), size - block_header_overhead);
+
+    const size_t remain_size = block_size(block) - (size + block_header_overhead);
+
+    tlsf_assert(block_to_ptr(remaining) == align_ptr(block_to_ptr(remaining), ALIGN_SIZE)
+                && "remaining block not aligned properly");
+
+    tlsf_assert(block_size(block) == remain_size + size + block_header_overhead);
+    block_set_size(remaining, remain_size);
+    tlsf_assert(block_size(remaining) >= block_size_min && "block split with invalid size");
+
+    block_set_size(block, size);
+    block_mark_as_free(remaining);
+
+    return remaining;
+}
+
+/* Absorb a free block's storage into an adjacent previous free block. */
+static block_header_t * block_absorb(block_header_t * prev, block_header_t * block)
+{
+    tlsf_assert(!block_is_last(prev) && "previous block can't be last");
+    /* Note: Leaves flags untouched. */
+    prev->size += block_size(block) + block_header_overhead;
+    block_link_next(prev);
+    return prev;
+}
+
+/* Merge a just-freed block with an adjacent previous free block. */
+static block_header_t * block_merge_prev(control_t * control, block_header_t * block)
+{
+    if(block_is_prev_free(block)) {
+        block_header_t * prev = block_prev(block);
+        tlsf_assert(prev && "prev physical block can't be null");
+        tlsf_assert(block_is_free(prev) && "prev block is not free though marked as such");
+        block_remove(control, prev);
+        block = block_absorb(prev, block);
+    }
+
+    return block;
+}
+
+/* Merge a just-freed block with an adjacent free block. */
+static block_header_t * block_merge_next(control_t * control, block_header_t * block)
+{
+    block_header_t * next = block_next(block);
+    tlsf_assert(next && "next physical block can't be null");
+
+    if(block_is_free(next)) {
+        tlsf_assert(!block_is_last(block) && "previous block can't be last");
+        block_remove(control, next);
+        block = block_absorb(block, next);
+    }
+
+    return block;
+}
+
+/* Trim any trailing block space off the end of a block, return to pool. */
+static void block_trim_free(control_t * control, block_header_t * block, size_t size)
+{
+    tlsf_assert(block_is_free(block) && "block must be free");
+    if(block_can_split(block, size)) {
+        block_header_t * remaining_block = block_split(block, size);
+        block_link_next(block);
+        block_set_prev_free(remaining_block);
+        block_insert(control, remaining_block);
+    }
+}
+
+/* Trim any trailing block space off the end of a used block, return to pool. */
+static void block_trim_used(control_t * control, block_header_t * block, size_t size)
+{
+    tlsf_assert(!block_is_free(block) && "block must be used");
+    if(block_can_split(block, size)) {
+        /* If the next block is free, we must coalesce. */
+        block_header_t * remaining_block = block_split(block, size);
+        block_set_prev_used(remaining_block);
+
+        remaining_block = block_merge_next(control, remaining_block);
+        block_insert(control, remaining_block);
+    }
+}
+
+static block_header_t * block_trim_free_leading(control_t * control, block_header_t * block, size_t size)
+{
+    block_header_t * remaining_block = block;
+    if(block_can_split(block, size)) {
+        /* We want the 2nd block. */
+        remaining_block = block_split(block, size - block_header_overhead);
+        block_set_prev_free(remaining_block);
+
+        block_link_next(block);
+        block_insert(control, block);
+    }
+
+    return remaining_block;
+}
+
+static block_header_t * block_locate_free(control_t * control, size_t size)
+{
+    int fl = 0, sl = 0;
+    block_header_t * block = 0;
+
+    if(size) {
+        mapping_search(size, &fl, &sl);
+
+        /*
+        ** mapping_search can futz with the size, so for excessively large sizes it can sometimes wind up
+        ** with indices that are off the end of the block array.
+        ** So, we protect against that here, since this is the only callsite of mapping_search.
+        ** Note that we don't need to check sl, since it comes from a modulo operation that guarantees it's always in range.
+        */
+        if(fl < FL_INDEX_COUNT) {
+            block = search_suitable_block(control, &fl, &sl);
+        }
+    }
+
+    if(block) {
+        tlsf_assert(block_size(block) >= size);
+        remove_free_block(control, block, fl, sl);
+    }
+
+    return block;
+}
+
+static void * block_prepare_used(control_t * control, block_header_t * block, size_t size)
+{
+    void * p = 0;
+    if(block) {
+        tlsf_assert(size && "size must be non-zero");
+        block_trim_free(control, block, size);
+        block_mark_as_used(block);
+        p = block_to_ptr(block);
+    }
+    return p;
+}
+
+/* Clear structure and point all empty lists at the null block. */
+static void control_constructor(control_t * control)
+{
+    int i, j;
+
+    control->block_null.next_free = &control->block_null;
+    control->block_null.prev_free = &control->block_null;
+
+    control->fl_bitmap = 0;
+    for(i = 0; i < FL_INDEX_COUNT; ++i) {
+        control->sl_bitmap[i] = 0;
+        for(j = 0; j < SL_INDEX_COUNT; ++j) {
+            control->blocks[i][j] = &control->block_null;
+        }
+    }
+}
+
+/*
+** Debugging utilities.
+*/
+
+typedef struct integrity_t {
+    int prev_status;
+    int status;
+} integrity_t;
+
+#define tlsf_insist(x) { tlsf_assert(x); if (!(x)) { status--; } }
+
+static void integrity_walker(void * ptr, size_t size, int used, void * user)
+{
+    block_header_t * block = block_from_ptr(ptr);
+    integrity_t * integ = tlsf_cast(integrity_t *, user);
+    const int this_prev_status = block_is_prev_free(block) ? 1 : 0;
+    const int this_status = block_is_free(block) ? 1 : 0;
+    const size_t this_block_size = block_size(block);
+
+    int status = 0;
+    LV_UNUSED(used);
+    tlsf_insist(integ->prev_status == this_prev_status && "prev status incorrect");
+    tlsf_insist(size == this_block_size && "block size incorrect");
+
+    integ->prev_status = this_status;
+    integ->status += status;
+}
+
+int lv_tlsf_check(lv_tlsf_t tlsf)
+{
+    int i, j;
+
+    control_t * control = tlsf_cast(control_t *, tlsf);
+    int status = 0;
+
+    /* Check that the free lists and bitmaps are accurate. */
+    for(i = 0; i < FL_INDEX_COUNT; ++i) {
+        for(j = 0; j < SL_INDEX_COUNT; ++j) {
+            const int fl_map = control->fl_bitmap & (1U << i);
+            const int sl_list = control->sl_bitmap[i];
+            const int sl_map = sl_list & (1U << j);
+            const block_header_t * block = control->blocks[i][j];
+
+            /* Check that first- and second-level lists agree. */
+            if(!fl_map) {
+                tlsf_insist(!sl_map && "second-level map must be null");
+            }
+
+            if(!sl_map) {
+                tlsf_insist(block == &control->block_null && "block list must be null");
+                continue;
+            }
+
+            /* Check that there is at least one free block. */
+            tlsf_insist(sl_list && "no free blocks in second-level map");
+            tlsf_insist(block != &control->block_null && "block should not be null");
+
+            while(block != &control->block_null) {
+                int fli, sli;
+                tlsf_insist(block_is_free(block) && "block should be free");
+                tlsf_insist(!block_is_prev_free(block) && "blocks should have coalesced");
+                tlsf_insist(!block_is_free(block_next(block)) && "blocks should have coalesced");
+                tlsf_insist(block_is_prev_free(block_next(block)) && "block should be free");
+                tlsf_insist(block_size(block) >= block_size_min && "block not minimum size");
+
+                mapping_insert(block_size(block), &fli, &sli);
+                tlsf_insist(fli == i && sli == j && "block size indexed in wrong list");
+                block = block->next_free;
+            }
+        }
+    }
+
+    return status;
+}
+
+#undef tlsf_insist
+
+static void default_walker(void * ptr, size_t size, int used, void * user)
+{
+    LV_UNUSED(user);
+    printf("\t%p %s size: %x (%p)\n", ptr, used ? "used" : "free", (unsigned int)size, (void *)block_from_ptr(ptr));
+}
+
+void lv_tlsf_walk_pool(lv_pool_t pool, lv_tlsf_walker walker, void * user)
+{
+    lv_tlsf_walker pool_walker = walker ? walker : default_walker;
+    block_header_t * block =
+        offset_to_block(pool, -(int)block_header_overhead);
+
+    while(block && !block_is_last(block)) {
+        pool_walker(
+            block_to_ptr(block),
+            block_size(block),
+            !block_is_free(block),
+            user);
+        block = block_next(block);
+    }
+}
+
+size_t lv_tlsf_block_size(void * ptr)
+{
+    size_t size = 0;
+    if(ptr) {
+        const block_header_t * block = block_from_ptr(ptr);
+        size = block_size(block);
+    }
+    return size;
+}
+
+int lv_tlsf_check_pool(lv_pool_t pool)
+{
+    /* Check that the blocks are physically correct. */
+    integrity_t integ = { 0, 0 };
+    lv_tlsf_walk_pool(pool, integrity_walker, &integ);
+
+    return integ.status;
+}
+
+/*
+** Size of the TLSF structures in a given memory block passed to
+** lv_tlsf_create, equal to the size of a control_t
+*/
+size_t lv_tlsf_size(void)
+{
+    return sizeof(control_t);
+}
+
+size_t lv_tlsf_align_size(void)
+{
+    return ALIGN_SIZE;
+}
+
+size_t lv_tlsf_block_size_min(void)
+{
+    return block_size_min;
+}
+
+size_t lv_tlsf_block_size_max(void)
+{
+    return block_size_max;
+}
+
+/*
+** Overhead of the TLSF structures in a given memory block passed to
+** lv_tlsf_add_pool, equal to the overhead of a free block and the
+** sentinel block.
+*/
+size_t lv_tlsf_pool_overhead(void)
+{
+    return 2 * block_header_overhead;
+}
+
+size_t lv_tlsf_alloc_overhead(void)
+{
+    return block_header_overhead;
+}
+
+lv_pool_t lv_tlsf_add_pool(lv_tlsf_t tlsf, void * mem, size_t bytes)
+{
+    block_header_t * block;
+    block_header_t * next;
+
+    const size_t pool_overhead = lv_tlsf_pool_overhead();
+    const size_t pool_bytes = align_down(bytes - pool_overhead, ALIGN_SIZE);
+
+    if(((ptrdiff_t)mem % ALIGN_SIZE) != 0) {
+        printf("lv_tlsf_add_pool: Memory must be aligned by %u bytes.\n",
+               (unsigned int)ALIGN_SIZE);
+        return 0;
+    }
+
+    if(pool_bytes < block_size_min || pool_bytes > block_size_max) {
+#if defined (TLSF_64BIT)
+        printf("lv_tlsf_add_pool: Memory size must be between 0x%x and 0x%x00 bytes.\n",
+               (unsigned int)(pool_overhead + block_size_min),
+               (unsigned int)((pool_overhead + block_size_max) / 256));
+#else
+        printf("lv_tlsf_add_pool: Memory size must be between %u and %u bytes.\n",
+               (unsigned int)(pool_overhead + block_size_min),
+               (unsigned int)(pool_overhead + block_size_max));
+#endif
+        return 0;
+    }
+
+    /*
+    ** Create the main free block. Offset the start of the block slightly
+    ** so that the prev_phys_block field falls outside of the pool -
+    ** it will never be used.
+    */
+    block = offset_to_block(mem, -(tlsfptr_t)block_header_overhead);
+    block_set_size(block, pool_bytes);
+    block_set_free(block);
+    block_set_prev_used(block);
+    block_insert(tlsf_cast(control_t *, tlsf), block);
+
+    /* Split the block to create a zero-size sentinel block. */
+    next = block_link_next(block);
+    block_set_size(next, 0);
+    block_set_used(next);
+    block_set_prev_free(next);
+
+    return mem;
+}
+
+void lv_tlsf_remove_pool(lv_tlsf_t tlsf, lv_pool_t pool)
+{
+    control_t * control = tlsf_cast(control_t *, tlsf);
+    block_header_t * block = offset_to_block(pool, -(int)block_header_overhead);
+
+    int fl = 0, sl = 0;
+
+    tlsf_assert(block_is_free(block) && "block should be free");
+    tlsf_assert(!block_is_free(block_next(block)) && "next block should not be free");
+    tlsf_assert(block_size(block_next(block)) == 0 && "next block size should be zero");
+
+    mapping_insert(block_size(block), &fl, &sl);
+    remove_free_block(control, block, fl, sl);
+}
+
+/*
+** TLSF main interface.
+*/
+
+#if _DEBUG
+int test_ffs_fls()
+{
+    /* Verify ffs/fls work properly. */
+    int rv = 0;
+    rv += (tlsf_ffs(0) == -1) ? 0 : 0x1;
+    rv += (tlsf_fls(0) == -1) ? 0 : 0x2;
+    rv += (tlsf_ffs(1) == 0) ? 0 : 0x4;
+    rv += (tlsf_fls(1) == 0) ? 0 : 0x8;
+    rv += (tlsf_ffs(0x80000000) == 31) ? 0 : 0x10;
+    rv += (tlsf_ffs(0x80008000) == 15) ? 0 : 0x20;
+    rv += (tlsf_fls(0x80000008) == 31) ? 0 : 0x40;
+    rv += (tlsf_fls(0x7FFFFFFF) == 30) ? 0 : 0x80;
+
+#if defined (TLSF_64BIT)
+    rv += (tlsf_fls_sizet(0x80000000) == 31) ? 0 : 0x100;
+    rv += (tlsf_fls_sizet(0x100000000) == 32) ? 0 : 0x200;
+    rv += (tlsf_fls_sizet(0xffffffffffffffff) == 63) ? 0 : 0x400;
+#endif
+
+    if(rv) {
+        printf("test_ffs_fls: %x ffs/fls tests failed.\n", rv);
+    }
+    return rv;
+}
+#endif
+
+lv_tlsf_t lv_tlsf_create(void * mem)
+{
+#if _DEBUG
+    if(test_ffs_fls()) {
+        return 0;
+    }
+#endif
+
+    if(((tlsfptr_t)mem % ALIGN_SIZE) != 0) {
+        printf("lv_tlsf_create: Memory must be aligned to %u bytes.\n",
+               (unsigned int)ALIGN_SIZE);
+        return 0;
+    }
+
+    control_constructor(tlsf_cast(control_t *, mem));
+
+    return tlsf_cast(lv_tlsf_t, mem);
+}
+
+lv_tlsf_t lv_tlsf_create_with_pool(void * mem, size_t bytes)
+{
+    lv_tlsf_t tlsf = lv_tlsf_create(mem);
+    lv_tlsf_add_pool(tlsf, (char *)mem + lv_tlsf_size(), bytes - lv_tlsf_size());
+    return tlsf;
+}
+
+void lv_tlsf_destroy(lv_tlsf_t tlsf)
+{
+    /* Nothing to do. */
+    LV_UNUSED(tlsf);
+}
+
+lv_pool_t lv_tlsf_get_pool(lv_tlsf_t tlsf)
+{
+    return tlsf_cast(lv_pool_t, (char *)tlsf + lv_tlsf_size());
+}
+
+void * lv_tlsf_malloc(lv_tlsf_t tlsf, size_t size)
+{
+    control_t * control = tlsf_cast(control_t *, tlsf);
+    const size_t adjust = adjust_request_size(size, ALIGN_SIZE);
+    block_header_t * block = block_locate_free(control, adjust);
+    return block_prepare_used(control, block, adjust);
+}
+
+void * lv_tlsf_memalign(lv_tlsf_t tlsf, size_t align, size_t size)
+{
+    control_t * control = tlsf_cast(control_t *, tlsf);
+    const size_t adjust = adjust_request_size(size, ALIGN_SIZE);
+
+    /*
+    ** We must allocate an additional minimum block size bytes so that if
+    ** our free block will leave an alignment gap which is smaller, we can
+    ** trim a leading free block and release it back to the pool. We must
+    ** do this because the previous physical block is in use, therefore
+    ** the prev_phys_block field is not valid, and we can't simply adjust
+    ** the size of that block.
+    */
+    const size_t gap_minimum = sizeof(block_header_t);
+    const size_t size_with_gap = adjust_request_size(adjust + align + gap_minimum, align);
+
+    /*
+    ** If alignment is less than or equals base alignment, we're done.
+    ** If we requested 0 bytes, return null, as lv_tlsf_malloc(0) does.
+    */
+    const size_t aligned_size = (adjust && align > ALIGN_SIZE) ? size_with_gap : adjust;
+
+    block_header_t * block = block_locate_free(control, aligned_size);
+
+    /* This can't be a static assert. */
+    tlsf_assert(sizeof(block_header_t) == block_size_min + block_header_overhead);
+
+    if(block) {
+        void * ptr = block_to_ptr(block);
+        void * aligned = align_ptr(ptr, align);
+        size_t gap = tlsf_cast(size_t,
+                               tlsf_cast(tlsfptr_t, aligned) - tlsf_cast(tlsfptr_t, ptr));
+
+        /* If gap size is too small, offset to next aligned boundary. */
+        if(gap && gap < gap_minimum) {
+            const size_t gap_remain = gap_minimum - gap;
+            const size_t offset = tlsf_max(gap_remain, align);
+            const void * next_aligned = tlsf_cast(void *,
+                                                  tlsf_cast(tlsfptr_t, aligned) + offset);
+
+            aligned = align_ptr(next_aligned, align);
+            gap = tlsf_cast(size_t,
+                            tlsf_cast(tlsfptr_t, aligned) - tlsf_cast(tlsfptr_t, ptr));
+        }
+
+        if(gap) {
+            tlsf_assert(gap >= gap_minimum && "gap size too small");
+            block = block_trim_free_leading(control, block, gap);
+        }
+    }
+
+    return block_prepare_used(control, block, adjust);
+}
+
+size_t lv_tlsf_free(lv_tlsf_t tlsf, const void * ptr)
+{
+    size_t size = 0;
+    /* Don't attempt to free a NULL pointer. */
+    if(ptr) {
+        control_t * control = tlsf_cast(control_t *, tlsf);
+        block_header_t * block = block_from_ptr(ptr);
+        tlsf_assert(!block_is_free(block) && "block already marked as free");
+        size = block->size;
+        block_mark_as_free(block);
+        block = block_merge_prev(control, block);
+        block = block_merge_next(control, block);
+        block_insert(control, block);
+    }
+
+    return size;
+}
+
+/*
+** The TLSF block information provides us with enough information to
+** provide a reasonably intelligent implementation of realloc, growing or
+** shrinking the currently allocated block as required.
+**
+** This routine handles the somewhat esoteric edge cases of realloc:
+** - a non-zero size with a null pointer will behave like malloc
+** - a zero size with a non-null pointer will behave like free
+** - a request that cannot be satisfied will leave the original buffer
+**   untouched
+** - an extended buffer size will leave the newly-allocated area with
+**   contents undefined
+*/
+void * lv_tlsf_realloc(lv_tlsf_t tlsf, void * ptr, size_t size)
+{
+    control_t * control = tlsf_cast(control_t *, tlsf);
+    void * p = 0;
+
+    /* Zero-size requests are treated as free. */
+    if(ptr && size == 0) {
+        lv_tlsf_free(tlsf, ptr);
+    }
+    /* Requests with NULL pointers are treated as malloc. */
+    else if(!ptr) {
+        p = lv_tlsf_malloc(tlsf, size);
+    }
+    else {
+        block_header_t * block = block_from_ptr(ptr);
+        block_header_t * next = block_next(block);
+
+        const size_t cursize = block_size(block);
+        const size_t combined = cursize + block_size(next) + block_header_overhead;
+        const size_t adjust = adjust_request_size(size, ALIGN_SIZE);
+        if(size > cursize && adjust == 0) {
+            /* The request is probably too large, fail */
+            return NULL;
+        }
+
+        tlsf_assert(!block_is_free(block) && "block already marked as free");
+
+        /*
+        ** If the next block is used, or when combined with the current
+        ** block, does not offer enough space, we must reallocate and copy.
+        */
+        if(adjust > cursize && (!block_is_free(next) || adjust > combined)) {
+            p = lv_tlsf_malloc(tlsf, size);
+            if(p) {
+                const size_t minsize = tlsf_min(cursize, size);
+                lv_memcpy(p, ptr, minsize);
+                lv_tlsf_free(tlsf, ptr);
+            }
+        }
+        else {
+            /* Do we need to expand to the next block? */
+            if(adjust > cursize) {
+                block_merge_next(control, block);
+                block_mark_as_used(block);
+            }
+
+            /* Trim the resulting block and return the original pointer. */
+            block_trim_used(control, block, adjust);
+            p = ptr;
+        }
+    }
+
+    return p;
+}
+
+#endif /*LV_STDLIB_BUILTIN*/
diff --git a/lib/lvgl/src/stdlib/builtin/lv_tlsf.h b/lib/lvgl/src/stdlib/builtin/lv_tlsf.h
new file mode 100644
index 00000000..98126636
--- /dev/null
+++ b/lib/lvgl/src/stdlib/builtin/lv_tlsf.h
@@ -0,0 +1,108 @@
+#include "../../lv_conf_internal.h"
+#if LV_USE_STDLIB_MALLOC == LV_STDLIB_BUILTIN
+
+#ifndef LV_TLSF_H
+#define LV_TLSF_H
+
+/*
+** Two Level Segregated Fit memory allocator, version 3.1.
+** Written by Matthew Conte
+**  http://tlsf.baisoku.org
+**
+** Based on the original documentation by Miguel Masmano:
+**  http://www.gii.upv.es/tlsf/main/docs
+**
+** This implementation was written to the specification
+** of the document, therefore no GPL restrictions apply.
+**
+** Copyright (c) 2006-2016, Matthew Conte
+** All rights reserved.
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are met:
+**     * Redistributions of source code must retain the above copyright
+**       notice, this list of conditions and the following disclaimer.
+**     * Redistributions in binary form must reproduce the above copyright
+**       notice, this list of conditions and the following disclaimer in the
+**       documentation and/or other materials provided with the distribution.
+**     * Neither the name of the copyright holder nor the
+**       names of its contributors may be used to endorse or promote products
+**       derived from this software without specific prior written permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+** DISCLAIMED. IN NO EVENT SHALL MATTHEW CONTE BE LIABLE FOR ANY
+** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+** (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include <stddef.h>
+
+#include "../../osal/lv_os.h"
+#include "../../misc/lv_ll.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/* lv_tlsf_t: a TLSF structure. Can contain 1 to N pools. */
+/* lv_pool_t: a block of memory that TLSF can manage. */
+typedef void * lv_tlsf_t;
+typedef void * lv_pool_t;
+
+typedef struct {
+#if LV_USE_OS
+    lv_mutex_t mutex;
+#endif
+    lv_tlsf_t tlsf;
+    size_t cur_used;
+    size_t max_used;
+    lv_ll_t  pool_ll;
+} lv_tlsf_state_t;
+
+/* Create/destroy a memory pool. */
+lv_tlsf_t lv_tlsf_create(void * mem);
+lv_tlsf_t lv_tlsf_create_with_pool(void * mem, size_t bytes);
+void lv_tlsf_destroy(lv_tlsf_t tlsf);
+lv_pool_t lv_tlsf_get_pool(lv_tlsf_t tlsf);
+
+/* Add/remove memory pools. */
+lv_pool_t lv_tlsf_add_pool(lv_tlsf_t tlsf, void * mem, size_t bytes);
+void lv_tlsf_remove_pool(lv_tlsf_t tlsf, lv_pool_t pool);
+
+/* malloc/memalign/realloc/free replacements. */
+void * lv_tlsf_malloc(lv_tlsf_t tlsf, size_t bytes);
+void * lv_tlsf_memalign(lv_tlsf_t tlsf, size_t align, size_t bytes);
+void * lv_tlsf_realloc(lv_tlsf_t tlsf, void * ptr, size_t size);
+size_t lv_tlsf_free(lv_tlsf_t tlsf, const void * ptr);
+
+/* Returns internal block size, not original request size */
+size_t lv_tlsf_block_size(void * ptr);
+
+/* Overheads/limits of internal structures. */
+size_t lv_tlsf_size(void);
+size_t lv_tlsf_align_size(void);
+size_t lv_tlsf_block_size_min(void);
+size_t lv_tlsf_block_size_max(void);
+size_t lv_tlsf_pool_overhead(void);
+size_t lv_tlsf_alloc_overhead(void);
+
+/* Debugging. */
+typedef void (*lv_tlsf_walker)(void * ptr, size_t size, int used, void * user);
+void lv_tlsf_walk_pool(lv_pool_t pool, lv_tlsf_walker walker, void * user);
+/* Returns nonzero if any internal consistency check fails. */
+int lv_tlsf_check(lv_tlsf_t tlsf);
+int lv_tlsf_check_pool(lv_pool_t pool);
+
+#if defined(__cplusplus)
+};
+#endif
+
+#endif /*LV_TLSF_H*/
+
+#endif /*LV_STDLIB_BUILTIN*/