enderice2/Fennix
1
0
Fork 0
mirror of https://github.com/EnderIce2/Fennix.git synced 2025-07-08 22:09:17 +00:00
Code Issues Actions Releases Wiki Activity

Changed a lot of files. Summary: profiler support; "SafeFunction"; UnlockDeadLock kernel config; Code optimization & more

Browse Source
This commit is contained in:
Alex
2022-11-28 08:25:37 +02:00
parent 2fba834d41
commit 0289054900
62 changed files with 1462 additions and 558 deletions
Download Patch File Download Diff File Expand all files Collapse all files

62
Library/printf.c
View File

@ -266,14 +266,14 @@ typedef union
// 1. Some compilers are finicky about this;
// 2. Some people may want to convert this to C89;
// 3. If you try to use it as C++, only C++20 supports compound literals
static inline double_with_bit_access get_bit_access(double x)
static inline __no_instrument_function double_with_bit_access get_bit_access(double x)
{
double_with_bit_access dwba;
dwba.F = x;
return dwba;
}
static inline int get_sign_bit(double x)
static inline __no_instrument_function int get_sign_bit(double x)
{
// The sign is stored in the highest bit
return (int)(get_bit_access(x).U >> (DOUBLE_SIZE_IN_BITS - 1));
@ -317,7 +317,7 @@ typedef struct
// or alternatively, that '\0' can be passed to the function in the output
// gadget. The former assumption holds within the printf library. It also
// assumes that the output gadget has been properly initialized.
static inline void putchar_via_gadget(output_gadget_t *gadget, char c)
static inline __no_instrument_function void putchar_via_gadget(output_gadget_t *gadget, char c)
{
printf_size_t write_pos = gadget->pos++;
// We're _always_ increasing pos, so as to count how may characters
@ -340,7 +340,7 @@ static inline void putchar_via_gadget(output_gadget_t *gadget, char c)
}
// Possibly-write the string-terminating '\0' character
static inline void append_termination_with_gadget(output_gadget_t *gadget)
static inline __no_instrument_function void append_termination_with_gadget(output_gadget_t *gadget)
{
if (gadget->function != NULL || gadget->max_chars == 0)
{
@ -356,13 +356,13 @@ static inline void append_termination_with_gadget(output_gadget_t *gadget)
// We can't use putchar_ as is, since our output gadget
// only takes pointers to functions with an extra argument
static inline void putchar_wrapper(char c, void *unused)
static inline __no_instrument_function void putchar_wrapper(char c, void *unused)
{
(void)unused;
putchar(c);
}
static inline output_gadget_t discarding_gadget(void)
static inline __no_instrument_function output_gadget_t discarding_gadget(void)
{
output_gadget_t gadget;
gadget.function = NULL;
@ -373,7 +373,7 @@ static inline output_gadget_t discarding_gadget(void)
return gadget;
}
static inline output_gadget_t buffer_gadget(char *buffer, size_t buffer_size)
static inline __no_instrument_function output_gadget_t buffer_gadget(char *buffer, size_t buffer_size)
{
printf_size_t usable_buffer_size = (buffer_size > PRINTF_MAX_POSSIBLE_BUFFER_SIZE) ? PRINTF_MAX_POSSIBLE_BUFFER_SIZE : (printf_size_t)buffer_size;
output_gadget_t result = discarding_gadget();
@ -385,7 +385,7 @@ static inline output_gadget_t buffer_gadget(char *buffer, size_t buffer_size)
return result;
}
static inline output_gadget_t function_gadget(void (*function)(char, void *), void *extra_arg)
static inline __no_instrument_function output_gadget_t function_gadget(void (*function)(char, void *), void *extra_arg)
{
output_gadget_t result = discarding_gadget();
result.function = function;
@ -394,7 +394,7 @@ static inline output_gadget_t function_gadget(void (*function)(char, void *), vo
return result;
}
static inline output_gadget_t extern_putchar_gadget(void)
static inline __no_instrument_function output_gadget_t extern_putchar_gadget(void)
{
return function_gadget(putchar_wrapper, NULL);
}
@ -403,7 +403,7 @@ static inline output_gadget_t extern_putchar_gadget(void)
// @return The length of the string (excluding the terminating 0) limited by 'maxsize'
// @note strlen uses size_t, but wes only use this function with printf_size_t
// variables - hence the signature.
static inline printf_size_t strnlen_s_(const char *str, printf_size_t maxsize)
static inline __no_instrument_function printf_size_t strnlen_s_(const char *str, printf_size_t maxsize)
{
const char *s;
for (s = str; *s && maxsize--; ++s)
@ -413,13 +413,13 @@ static inline printf_size_t strnlen_s_(const char *str, printf_size_t maxsize)
// internal test if char is a digit (0-9)
// @return true if char is a digit
static inline bool is_digit_(char ch)
static inline __no_instrument_function bool is_digit_(char ch)
{
return (ch >= '0') && (ch <= '9');
}
// internal ASCII string to printf_size_t conversion
static printf_size_t atou_(const char **str)
static __no_instrument_function printf_size_t atou_(const char **str)
{
printf_size_t i = 0U;
while (is_digit_(**str))
@ -430,7 +430,7 @@ static printf_size_t atou_(const char **str)
}
// output the specified string in reverse, taking care of any zero-padding
static void out_rev_(output_gadget_t *output, const char *buf, printf_size_t len, printf_size_t width, printf_flags_t flags)
static __no_instrument_function void out_rev_(output_gadget_t *output, const char *buf, printf_size_t len, printf_size_t width, printf_flags_t flags)
{
const printf_size_t start_pos = output->pos;
@ -461,7 +461,7 @@ static void out_rev_(output_gadget_t *output, const char *buf, printf_size_t len
// Invoked by print_integer after the actual number has been printed, performing necessary
// work on the number's prefix (as the number is initially printed in reverse order)
static void print_integer_finalization(output_gadget_t *output, char *buf, printf_size_t len, bool negative, numeric_base_t base, printf_size_t precision, printf_size_t width, printf_flags_t flags)
static __no_instrument_function void print_integer_finalization(output_gadget_t *output, char *buf, printf_size_t len, bool negative, numeric_base_t base, printf_size_t precision, printf_size_t width, printf_flags_t flags)
{
printf_size_t unpadded_len = len;
@ -545,7 +545,7 @@ static void print_integer_finalization(output_gadget_t *output, char *buf, print
}
// An internal itoa-like function
static void print_integer(output_gadget_t *output, printf_unsigned_value_t value, bool negative, numeric_base_t base, printf_size_t precision, printf_size_t width, printf_flags_t flags)
static __no_instrument_function void print_integer(output_gadget_t *output, printf_unsigned_value_t value, bool negative, numeric_base_t base, printf_size_t precision, printf_size_t width, printf_flags_t flags)
{
char buf[PRINTF_INTEGER_BUFFER_SIZE];
printf_size_t len = 0U;
@ -604,7 +604,7 @@ static const double powers_of_10[NUM_DECIMAL_DIGITS_IN_INT64_T] = {
// Break up a double number - which is known to be a finite non-negative number -
// into its base-10 parts: integral - before the decimal point, and fractional - after it.
// Taken the precision into account, but does not change it even internally.
static struct double_components get_components(double number, printf_size_t precision)
static struct __no_instrument_function double_components get_components(double number, printf_size_t precision)
{
struct double_components number_;
number_.is_negative = get_sign_bit(number);
@ -741,7 +741,7 @@ static struct double_components get_normalized_components(bool negative, printf_
}
#endif // PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS
static void print_broken_up_decimal(
static __no_instrument_function void print_broken_up_decimal(
struct double_components number_, output_gadget_t *output, printf_size_t precision,
printf_size_t width, printf_flags_t flags, char *buf, printf_size_t len)
{
@ -843,7 +843,7 @@ static void print_broken_up_decimal(
}
// internal ftoa for fixed decimal floating point
static void print_decimal_number(output_gadget_t *output, double number, printf_size_t precision, printf_size_t width, printf_flags_t flags, char *buf, printf_size_t len)
static __no_instrument_function void print_decimal_number(output_gadget_t *output, double number, printf_size_t precision, printf_size_t width, printf_flags_t flags, char *buf, printf_size_t len)
{
struct double_components value_ = get_components(number, precision);
print_broken_up_decimal(value_, output, precision, width, flags, buf, len);
@ -916,7 +916,7 @@ static double pow10_of_int(int floored_exp10)
return dwba.F;
}
static void print_exponential_number(output_gadget_t *output, double number, printf_size_t precision, printf_size_t width, printf_flags_t flags, char *buf, printf_size_t len)
static __no_instrument_function void print_exponential_number(output_gadget_t *output, double number, printf_size_t precision, printf_size_t width, printf_flags_t flags, char *buf, printf_size_t len)
{
const bool negative = get_sign_bit(number);
// This number will decrease gradually (by factors of 10) as we "extract" the exponent out of it
@ -1039,7 +1039,7 @@ static void print_exponential_number(output_gadget_t *output, double number, pri
}
#endif // PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS
static void print_floating_point(output_gadget_t *output, double value, printf_size_t precision, printf_size_t width, printf_flags_t flags, bool prefer_exponential)
static __no_instrument_function void print_floating_point(output_gadget_t *output, double value, printf_size_t precision, printf_size_t width, printf_flags_t flags, bool prefer_exponential)
{
char buf[PRINTF_DECIMAL_BUFFER_SIZE];
printf_size_t len = 0U;
@ -1098,7 +1098,7 @@ static void print_floating_point(output_gadget_t *output, double value, printf_s
// Advances the format pointer past the flags, and returns the parsed flags
// due to the characters passed
static printf_flags_t parse_flags(const char **format)
static __no_instrument_function printf_flags_t parse_flags(const char **format)
{
printf_flags_t flags = 0U;
do
@ -1131,7 +1131,7 @@ static printf_flags_t parse_flags(const char **format)
} while (true);
}
static inline void format_string_loop(output_gadget_t *output, const char *format, va_list args)
static inline __no_instrument_function void format_string_loop(output_gadget_t *output, const char *format, va_list args)
{
#if PRINTF_CHECK_FOR_NUL_IN_FORMAT_SPECIFIER
#define ADVANCE_IN_FORMAT_STRING(cptr_) \
@ -1513,7 +1513,7 @@ static inline void format_string_loop(output_gadget_t *output, const char *forma
}
// internal vsnprintf - used for implementing _all library functions
static int vsnprintf_impl(output_gadget_t *output, const char *format, va_list args)
static __no_instrument_function int vsnprintf_impl(output_gadget_t *output, const char *format, va_list args)
{
// Note: The library only calls vsnprintf_impl() with output->pos being 0. However, it is
// possible to call this function with a non-zero pos value for some "remedial printing".
@ -1528,30 +1528,30 @@ static int vsnprintf_impl(output_gadget_t *output, const char *format, va_list a
///////////////////////////////////////////////////////////////////////////////
int vprintf_(const char *format, va_list arg)
__no_instrument_function int vprintf_(const char *format, va_list arg)
{
output_gadget_t gadget = extern_putchar_gadget();
return vsnprintf_impl(&gadget, format, arg);
}
int vsnprintf_(char *s, size_t n, const char *format, va_list arg)
__no_instrument_function int vsnprintf_(char *s, size_t n, const char *format, va_list arg)
{
output_gadget_t gadget = buffer_gadget(s, n);
return vsnprintf_impl(&gadget, format, arg);
}
int vsprintf_(char *s, const char *format, va_list arg)
__no_instrument_function int vsprintf_(char *s, const char *format, va_list arg)
{
return vsnprintf_(s, PRINTF_MAX_POSSIBLE_BUFFER_SIZE, format, arg);
}
int vfctprintf(void (*out)(char c, void *extra_arg), void *extra_arg, const char *format, va_list arg)
__no_instrument_function int vfctprintf(void (*out)(char c, void *extra_arg), void *extra_arg, const char *format, va_list arg)
{
output_gadget_t gadget = function_gadget(out, extra_arg);
return vsnprintf_impl(&gadget, format, arg);
}
int printf_(const char *format, ...)
__no_instrument_function int printf_(const char *format, ...)
{
va_list args;
va_start(args, format);
@ -1560,7 +1560,7 @@ int printf_(const char *format, ...)
return ret;
}
int sprintf_(char *s, const char *format, ...)
__no_instrument_function int sprintf_(char *s, const char *format, ...)
{
va_list args;
va_start(args, format);
@ -1569,7 +1569,7 @@ int sprintf_(char *s, const char *format, ...)
return ret;
}
int snprintf_(char *s, size_t n, const char *format, ...)
__no_instrument_function int snprintf_(char *s, size_t n, const char *format, ...)
{
va_list args;
va_start(args, format);
@ -1578,7 +1578,7 @@ int snprintf_(char *s, size_t n, const char *format, ...)
return ret;
}
int fctprintf(void (*out)(char c, void *extra_arg), void *extra_arg, const char *format, ...)
__no_instrument_function int fctprintf(void (*out)(char c, void *extra_arg), void *extra_arg, const char *format, ...)
{
va_list args;
va_start(args, format);