/*
 * Copyright (c) 2019-2023 Beijing Hanwei Innovation Technology Ltd. Co. and
 * its subsidiaries and affiliates (collectly called MKSEMI).
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form, except as embedded into an MKSEMI
 *    integrated circuit in a product or a software update for such product,
 *    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.
 *
 * 3. Neither the name of MKSEMI nor the names of its contributors may be used
 *    to endorse or promote products derived from this software without
 *    specific prior written permission.
 *
 * 4. This software, with or without modification, must only be used with a
 *    MKSEMI integrated circuit.
 *
 * 5. Any software provided in binary form under this license must not be
 *    reverse engineered, decompiled, modified and/or disassembled.
 *
 * THIS SOFTWARE IS PROVIDED BY MKSEMI "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL MKSEMI OR CONTRIBUTORS 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 "libc_rom.h"

#ifndef STD_LIBC

#if defined(__ARMCC_VERSION)
static const struct LIBC_ROM_T *libc_rom __attribute__((section(".bss.noinit")));
#elif defined(__ICCARM__)
__no_init static const struct LIBC_ROM_T *libc_rom;
#elif defined(__GNUC__)
static const struct LIBC_ROM_T *libc_rom __attribute__((section(".noinit")));
#else
#warning "Confirm compiler version"
#endif

void update_libc_rom_table(void)
{
    // A4
    if (*(const volatile uint32_t *)(0x4000000C) == 0x00000020)
    {
        libc_rom = (const struct LIBC_ROM_T *)0x0301d624;
    }
    else
    {
        libc_rom = (const struct LIBC_ROM_T *)0x0301cf30;
    }
}

#if !defined(__ICCARM__)
void *memcpy(void *s1, const void *s2, size_t n)
{
    return libc_rom->memcpy(s1, s2, n);
}

void *memmove(void *s1, const void *s2, size_t n)
{
    return libc_rom->memmove(s1, s2, n);
}
#endif

char *strcpy(char *s1, const char *s2)
{
    return libc_rom->strcpy(s1, s2);
}

char *strncpy(char *s1, const char *s2, size_t n)
{
    return libc_rom->strncpy(s1, s2, n);
}

char *strcat(char *s1, const char *s2)
{
    return libc_rom->strcat(s1, s2);
}

char *strncat(char *s1, const char *s2, size_t n)
{
    return libc_rom->strncat(s1, s2, n);
}

int memcmp(const void *s1, const void *s2, size_t n)
{
    return libc_rom->memcmp(s1, s2, n);
}

int strcmp(const char *s1, const char *s2)
{
    return libc_rom->strcmp(s1, s2);
}

int strncmp(const char *s1, const char *s2, size_t n)
{
    return libc_rom->strncmp(s1, s2, n);
}

int strcasecmp(const char *s1, const char *s2)
{
    return libc_rom->strcasecmp(s1, s2);
}

int strncasecmp(const char *s1, const char *s2, size_t n)
{
    return libc_rom->strncasecmp(s1, s2, n);
}

int strcoll(const char *s1, const char *s2)
{
    return libc_rom->strcoll(s1, s2);
}

size_t strxfrm(char *s1, const char *s2, size_t n)
{
    return libc_rom->strxfrm(s1, s2, n);
}

void *memchr(const void *s, int c, size_t n)
{
    return libc_rom->memchr(s, c, n);
}

char *strchr(const char *s, int c)
{
    return libc_rom->strchr(s, c);
}

size_t strcspn(const char *s1, const char *s2)
{
    return libc_rom->strcspn(s1, s2);
}

char *strpbrk(const char *s1, const char *s2)
{
    return libc_rom->strpbrk(s1, s2);
}

char *strrchr(const char *s, int c)
{
    return libc_rom->strrchr(s, c);
}

size_t strspn(const char *s1, const char *s2)
{
    return libc_rom->strspn(s1, s2);
}

char *strstr(const char *s1, const char *s2)
{
    return libc_rom->strstr(s1, s2);
}

char *strtok(char *s1, const char *s2)
{
    return libc_rom->strtok(s1, s2);
}

#if !defined(__ICCARM__)
void *memset(void *s, int c, size_t n)
{
    return libc_rom->memset(s, c, n);
}
#endif

char *strerror(int errnum)
{
    return libc_rom->strerror(errnum);
}

size_t strlen(const char *s)
{
    return libc_rom->strlen(s);
}

size_t strlcpy(char *dst, const char *src, size_t len)
{
    return libc_rom->strlcpy(dst, src, len);
}

size_t strlcat(char *dst, const char *src, size_t len)
{
    return libc_rom->strlcat(dst, src, len);
}

int sprintf(char *s, const char *format, ...)
{
    va_list ap;
    int len;

    va_start(ap, format);
    len = libc_rom->vsnprintf(s, -(size_t)s, format, ap);
    va_end(ap);
    return (len);
}

int snprintf(char *s, size_t n, const char *format, ...)
{
    va_list ap;
    int len;

    va_start(ap, format);
    len = libc_rom->vsnprintf(s, n, format, ap);
    va_end(ap);
    return (len);
}

int vsprintf(char *s, const char *format, va_list arg)
{
    return libc_rom->vsprintf(s, format, arg);
}

int vsnprintf(char *s, size_t n, const char *format, va_list arg)
{
    return libc_rom->vsnprintf(s, n, format, arg);
}

int sscanf(const char *s, const char *format, ...)
{
    va_list args;
    int i;

    va_start(args, format);
    i = libc_rom->vsscanf(s, format, args);
    va_end(args);
    return i;
}

int vsscanf(const char *s, const char *format, va_list arg)
{
    return libc_rom->vsscanf(s, format, arg);
}

double atof(const char *nptr)
{
    return libc_rom->atof(nptr);
}

int atoi(const char *nptr)
{
    return libc_rom->atoi(nptr);
}

long int atol(const char *nptr)
{
    return libc_rom->atol(nptr);
}

long long atoll(const char *nptr)
{
    return libc_rom->atoll(nptr);
}

double strtod(const char *nptr, char **endptr)
{
    return libc_rom->strtod(nptr, endptr);
}

long int strtol(const char *nptr, char **endptr, int base)
{
    return libc_rom->strtol(nptr, endptr, base);
}

unsigned long int strtoul(const char *nptr, char **endptr, int base)
{
    return libc_rom->strtoul(nptr, endptr, base);
}

long long strtoll(const char *nptr, char **endptr, int base)
{
    return libc_rom->strtoll(nptr, endptr, base);
}

unsigned long long strtoull(const char *nptr, char **endptr, int base)
{
    return libc_rom->strtoull(nptr, endptr, base);
}

int rand(void)
{
    return libc_rom->rand();
}

void srand(unsigned int seed)
{
    libc_rom->srand(seed);
}

void *bsearch(const void *key, const void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *))
{
    return libc_rom->bsearch(key, base, nmemb, size, compar);
}

void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *))
{
    libc_rom->qsort(base, nmemb, size, compar);
}

#if !defined(__ICCARM__)
int abs(int j)
{
    return libc_rom->abs(j);
}

div_t div(int numer, int denom)
{
    return libc_rom->div(numer, denom);
}

long int labs(long int j)
{
    return libc_rom->labs(j);
}

ldiv_t ldiv(long int numer, long int denom)
{
    return libc_rom->ldiv(numer, denom);
}

long long llabs(long long j)
{
    return libc_rom->llabs(j);
}

lldiv_t lldiv(long long numer, long long denom)
{
    return libc_rom->lldiv(numer, denom);
}
#endif

double acos(double x)
{
    return libc_rom->acos(x);
}

double asin(double x)
{
    return libc_rom->asin(x);
}

double atan(double x)
{
    return libc_rom->atan(x);
}

double atan2(double y, double x)
{
    return libc_rom->atan2(y, x);
}

double cos(double x)
{
    return libc_rom->cos(x);
}

double sin(double x)
{
    return libc_rom->sin(x);
}

double tan(double x)
{
    return libc_rom->tan(x);
}

double cosh(double x)
{
    return libc_rom->cosh(x);
}

double sinh(double x)
{
    return libc_rom->sinh(x);
}

double tanh(double x)
{
    return libc_rom->tanh(x);
}

double exp(double x)
{
    return libc_rom->exp(x);
}

double frexp(double value, int *exp)
{
    return libc_rom->frexp(value, exp);
}

double ldexp(double x, int exp)
{
    return libc_rom->ldexp(x, exp);
}

double log(double x)
{
    return libc_rom->log(x);
}

double log10(double x)
{
    return libc_rom->log10(x);
}

double modf(double value, double *iptr)
{
    return libc_rom->modf(value, iptr);
}

double pow(double x, double y)
{
    return libc_rom->pow(x, y);
}

double sqrt(double x)
{
    return libc_rom->sqrt(x);
}

double ceil(double x)
{
    return libc_rom->ceil(x);
}

double fabs(double x)
{
    return libc_rom->fabs(x);
}

double floor(double d)
{
    return libc_rom->floor(d);
}

double fmod(double x, double y)
{
    return libc_rom->fmod(x, y);
}

double acosh(double x)
{
    return libc_rom->acosh(x);
}

double asinh(double x)
{
    return libc_rom->asinh(x);
}

double atanh(double x)
{
    return libc_rom->atanh(x);
}

double cbrt(double x)
{
    return libc_rom->cbrt(x);
}

double erf(double x)
{
    return libc_rom->erf(x);
}

double erfc(double x)
{
    return libc_rom->erfc(x);
}

double expm1(double x)
{
    return libc_rom->expm1(x);
}

double hypot(double x, double y)
{
    return libc_rom->hypot(x, y);
}

double remainder(double x, double y)
{
    return libc_rom->remainder(x, y);
}

double rint(double x)
{
    return libc_rom->rint(x);
}

double scalbln(double x, long int n)
{
    return libc_rom->scalbln(x, n);
}

float scalblnf(float x, long int n)
{
    return libc_rom->scalblnf(x, n);
}

long double scalblnl(long double x, long int n)
{
    return libc_rom->scalblnl(x, n);
}

float fabsf(float x)
{
    return libc_rom->fabsf(x);
}

float sinf(float x)
{
    return libc_rom->sinf(x);
}

float cosf(float x)
{
    return libc_rom->cosf(x);
}

float tanf(float x)
{
    return libc_rom->tanf(x);
}

float acosf(float x)
{
    return libc_rom->acosf(x);
}

float asinf(float x)
{
    return libc_rom->asinf(x);
}

float atanf(float x)
{
    return libc_rom->atanf(x);
}

float atan2f(float y, float x)
{
    return libc_rom->atan2f(y, x);
}

float sinhf(float x)
{
    return libc_rom->sinhf(x);
}

float coshf(float x)
{
    return libc_rom->coshf(x);
}

float tanhf(float x)
{
    return libc_rom->tanhf(x);
}

float expf(float x)
{
    return libc_rom->expf(x);
}

float logf(float x)
{
    return libc_rom->logf(x);
}

float log10f(float x)
{
    return libc_rom->log10f(x);
}

float powf(float x, float y)
{
    return libc_rom->powf(x, y);
}

float sqrtf(float x)
{
    return libc_rom->sqrtf(x);
}

float ldexpf(float x, int exp)
{
    return libc_rom->ldexpf(x, exp);
}

float frexpf(float value, int *exp)
{
    return libc_rom->frexpf(value, exp);
}

float ceilf(float x)
{
    return libc_rom->ceilf(x);
}

float floorf(float x)
{
    return libc_rom->floorf(x);
}

float fmodf(float x, float y)
{
    return libc_rom->fmodf(x, y);
}

float modff(float value, float *iptr)
{
    return libc_rom->modff(value, iptr);
}

long double acosl(long double x)
{
    return libc_rom->acosl(x);
}

long double asinl(long double x)
{
    return libc_rom->asinl(x);
}

long double atanl(long double x)
{
    return libc_rom->atanl(x);
}

long double atan2l(long double x, long double y)
{
    return libc_rom->atan2l(x, y);
}

long double ceill(long double x)
{
    return libc_rom->ceill(x);
}

long double cosl(long double x)
{
    return libc_rom->cosl(x);
}

long double coshl(long double x)
{
    return libc_rom->coshl(x);
}

long double expl(long double x)
{
    return libc_rom->expl(x);
}

long double fabsl(long double x)
{
    return libc_rom->fabsl(x);
}

long double floorl(long double x)
{
    return libc_rom->floorl(x);
}

long double fmodl(long double x, long double y)
{
    return libc_rom->fmodl(x, y);
}

long double frexpl(long double x, int *p)
{
    return libc_rom->frexpl(x, p);
}

long double ldexpl(long double x, int p)
{
    return libc_rom->ldexpl(x, p);
}

long double logl(long double x)
{
    return libc_rom->logl(x);
}

long double log10l(long double x)
{
    return libc_rom->log10l(x);
}

long double modfl(long double x, long double *p)
{
    return libc_rom->modfl(x, p);
}

long double powl(long double x, long double y)
{
    return libc_rom->powl(x, y);
}

long double sinl(long double x)
{
    return libc_rom->sinl(x);
}

long double sinhl(long double x)
{
    return libc_rom->sinhl(x);
}

long double sqrtl(long double x)
{
    return libc_rom->sqrtl(x);
}

long double tanl(long double x)
{
    return libc_rom->tanl(x);
}

long double tanhl(long double x)
{
    return libc_rom->tanhl(x);
}

float acoshf(float x)
{
    return libc_rom->acoshf(x);
}

long double acoshl(long double x)
{
    return libc_rom->acoshl(x);
}

float asinhf(float x)
{
    return libc_rom->asinhf(x);
}

long double asinhl(long double x)
{
    return libc_rom->asinhl(x);
}

float atanhf(float x)
{
    return libc_rom->atanhf(x);
}

long double atanhl(long double x)
{
    return libc_rom->atanhl(x);
}

long double copysignl(long double x, long double y)
{
    return libc_rom->copysignl(x, y);
}

float cbrtf(float x)
{
    return libc_rom->cbrtf(x);
}

long double cbrtl(long double x)
{
    return libc_rom->cbrtl(x);
}

float erff(float x)
{
    return libc_rom->erff(x);
}

long double erfl(long double x)
{
    return libc_rom->erfl(x);
}

float erfcf(float x)
{
    return libc_rom->erfcf(x);
}

long double erfcl(long double x)
{
    return libc_rom->erfcl(x);
}

float expm1f(float x)
{
    return libc_rom->expm1f(x);
}

long double expm1l(long double x)
{
    return libc_rom->expm1l(x);
}

float log1pf(float x)
{
    return libc_rom->log1pf(x);
}

long double log1pl(long double x)
{
    return libc_rom->log1pl(x);
}

float hypotf(float x, float y)
{
    return libc_rom->hypotf(x, y);
}

long double hypotl(long double x, long double y)
{
    return libc_rom->hypotl(x, y);
}

float remainderf(float x, float y)
{
    return libc_rom->remainderf(x, y);
}

long double remainderl(long double x, long double y)
{
    return libc_rom->remainderl(x, y);
}

float rintf(float x)
{
    return libc_rom->rintf(x);
}

long double rintl(long double x)
{
    return libc_rom->rintl(x);
}

double exp2(double x)
{
    return libc_rom->exp2(x);
}

float exp2f(float x)
{
    return libc_rom->exp2f(x);
}

long double exp2l(long double x)
{
    return libc_rom->exp2l(x);
}

double fdim(double x, double y)
{
    return libc_rom->fdim(x, y);
}

float fdimf(float x, float y)
{
    return libc_rom->fdimf(x, y);
}

long double fdiml(long double x, long double y)
{
    return libc_rom->fdiml(x, y);
}

double fma(double x, double y, double z)
{
    return libc_rom->fma(x, y, z);
}

float fmaf(float x, float y, float z)
{
    return libc_rom->fmaf(x, y, z);
}

double fmax(double x, double y)
{
    return libc_rom->fmax(x, y);
}

float fmaxf(float x, float y)
{
    return libc_rom->fmaxf(x, y);
}

long double fmaxl(long double x, long double y)
{
    return libc_rom->fmaxl(x, y);
}

double fmin(double x, double y)
{
    return libc_rom->fmin(x, y);
}

float fminf(float x, float y)
{
    return libc_rom->fminf(x, y);
}

long double fminl(long double x, long double y)
{
    return libc_rom->fminl(x, y);
}

#if !defined(__GNUC__)
double log2(double x)
{
    return libc_rom->log2(x);
}
#endif

float log2f(float x)
{
    return libc_rom->log2f(x);
}

long double log2l(long double x)
{
    return libc_rom->log2l(x);
}

long lrint(double x)
{
    return libc_rom->lrint(x);
}

long lrintf(float x)
{
    return libc_rom->lrintf(x);
}

long long llrint(double x)
{
    return libc_rom->llrint(x);
}

long long llrintf(float x)
{
    return libc_rom->llrintf(x);
}

long lround(double x)
{
    return libc_rom->lround(x);
}

long lroundf(float x)
{
    return libc_rom->lroundf(x);
}

long long llround(double x)
{
    return libc_rom->llround(x);
}

long long llroundf(float x)
{
    return libc_rom->llroundf(x);
}

double nan(const char *tagp)
{
    return libc_rom->nan(tagp);
}

float nanf(const char *tagp)
{
    return libc_rom->nanf(tagp);
}

double nearbyint(double x)
{
    return libc_rom->nearbyint(x);
}

float nearbyintf(float x)
{
    return libc_rom->nearbyintf(x);
}

long double nearbyintl(long double x)
{
    return libc_rom->nearbyintl(x);
}

double remquo(double x, double y, int *quo)
{
    return libc_rom->remquo(x, y, quo);
}

float remquof(float x, float y, int *quo)
{
    return libc_rom->remquof(x, y, quo);
}

double round(double x)
{
    return libc_rom->round(x);
}

float roundf(float x)
{
    return libc_rom->roundf(x);
}

long double roundl(long double x)
{
    return libc_rom->roundl(x);
}

double tgamma(double x)
{
    return libc_rom->tgamma(x);
}

float tgammaf(float x)
{
    return libc_rom->tgammaf(x);
}

long double tgammal(long double x)
{
    return libc_rom->tgammal(x);
}

double trunc(double x)
{
    return libc_rom->trunc(x);
}

float truncf(float x)
{
    return libc_rom->truncf(x);
}

long double truncl(long double x)
{
    return libc_rom->truncl(x);
}

#else
#if defined(__ARMCC_VERSION)
static const void *libc_rom __attribute__((section(".bss.noinit"), used));
#endif
#endif