reference_model/src/func_debug.cc - tosa/reference_model - Gitiles


 // Copyright (c) 2020, ARM Limited.
 //
 //    Licensed under the Apache License, Version 2.0 (the "License");
 //    you may not use this file except in compliance with the License.
 //    You may obtain a copy of the License at
 //
 //         http://www.apache.org/licenses/LICENSE-2.0
 //
 //    Unless required by applicable law or agreed to in writing, software
 //    distributed under the License is distributed on an "AS IS" BASIS,
 //    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 //    See the License for the specific language governing permissions and
 //    limitations under the License.

 #include <ctype.h>
 #include <signal.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>

 #ifndef _MSC_VER
 #include <execinfo.h>
 #include <sys/prctl.h>
 #include <sys/ptrace.h>
 #include <sys/wait.h>
 #include <unistd.h>
 #endif

 #include "func_debug.h"

 #define MAX_FRAMES 100

 #ifndef _MSC_VER
 pid_t func_print_backtrace_helper(int num_tries, int sig);
 #endif

 void func_print_backtrace(FILE* out, int sig)
 {
 #ifndef _MSC_VER
     for (int i = 0; i < 2; i++)
     {
         const pid_t child_pid = func_print_backtrace_helper(i, sig);
         if (child_pid < 0)
         {
             perror("Backtrace generation failed on fork");
             break;
         }

         int status = 0;
         waitpid(child_pid, &status, 0);
         if (WEXITSTATUS(status) == 0)
         {
             break;
         }
     }
 #endif
 }

 #ifndef _MSC_VER
 pid_t func_print_backtrace_helper(int num_tries, int sig)
 {
     const pid_t child_pid = fork();

     if (child_pid)
     {
         return 0;
     }

     const pid_t ppid = getppid();

     printf("Attaching debugger to pid %d\n", ppid);
     // Check if we're in a debugger
     if (ptrace(PTRACE_ATTACH, ppid, 0, 0) == 0)
     {
         // If we reach this point, no debugger is present
         // Undo effects of PTRACE_ATTACH
         waitpid(ppid, NULL, 0);
         ptrace(PTRACE_CONT, 0, 0, 0);
         ptrace(PTRACE_DETACH, ppid, 0, 0);

         dup2(STDERR_FILENO, STDOUT_FILENO);

         char parent_pid[20];
         snprintf(parent_pid, sizeof(parent_pid), "attach %d", ppid);
         fprintf(stdout, "Caught signal %d (%s)\n", sig, strsignal(sig));

         execlp("gdb", "gdb", "--batch", "-n", "-ex",
                // Don't print startup messages for each thread
                "-ex", "set print thread-events off", "-ex", parent_pid,
                // Turn off pagination
                "-ex", "set height 0",
                // Print a backtrace for the current thread
                "-ex", "thread $_thread", "-ex", "bt",
                // Print a backtrace for the main thread (uncomment the next two lines, if desired)
                //"-ex", "thread 1",
                //"-ex", "bt",
                // Print a backtrace for all thread (TMI)
                //"-ex", "thread apply all bt",
                NULL);

         // If we reach this point, it is bad. Attempt to print an error before exiting.
         perror("Backtrace generation failed to invoke gdb");
         exit(1);
     }

     // Debugger present.  Exit here.
     exit(0);

     return 0;
 }
 #endif

 void func_backtrace_signal_handler(int sig)
 {
     func_print_backtrace(NULL, sig);
     exit(1);
 }

 // Note: this overwrites other signal handlers.  May want to make this
 // more friendly sometime
 void func_enable_signal_handlers()
 {
     static const int sig_list[] = { SIGABRT, SIGSEGV, SIGILL, SIGFPE };

     if (getenv("FUNC_NO_SIG_HANDLERS"))
     {
         return;
     }

     for (size_t i = 0; i < sizeof(sig_list) / sizeof(int); i++)
     {
         struct sigaction act;

         bzero(&act, sizeof(act));
         act.sa_handler = func_backtrace_signal_handler;

         if (sigaction(sig_list[i], &act, NULL))
         {
             perror("Error calling sigaction");
         }
     }
 }

 const char* func_debug_mode_str_table[] = {
 #define DEBUG_MODE(NAME, BIT) #NAME,
 #include "debug_modes.def"
 #undef DEBUG_MODE
 };

 #define DEBUG_MASK_COUNT (sizeof(func_debug_mode_str_table) / sizeof(const char*))

 const char* func_debug_verbosity_str_table[] = { "NONE", "INFO", "IFACE", "LOW", "MED", "HIGH" };

 const uint32_t func_debug_verbosity_mask_table[] = { DEBUG_VERB_NONE, DEBUG_VERB_INFO, DEBUG_VERB_IFACE,
                                                      DEBUG_VERB_LOW,  DEBUG_VERB_MED,  DEBUG_VERB_HIGH };

 #define DEBUG_VERBOSITY_COUNT (sizeof(func_debug_verbosity_str_table) / sizeof(const char*))

 // Initialize the debug mode
 int func_init_debug(func_debug_t* func_debug, uint64_t inst_id)
 {
     // Set the default debug settings
     bzero(func_debug, sizeof(func_debug_t));
     func_debug_set_mask(func_debug, DEBUG_NONE);
     func_debug_set_verbosity(func_debug, DEBUG_VERB_NONE);
     func_debug_set_inst_mask(func_debug, DEBUG_INST_ALL);
     func_debug->func_debug_file = stderr;
     func_debug_set_captured_warnings(func_debug, 0);
     func_debug_set_output_unbuffered(func_debug, false);
     func_debug->inst_id = inst_id;

     return 0;
 }

 int func_fini_debug(func_debug_t* func_debug)
 {
     if (func_debug->record_warnings)
     {
         func_debug_set_captured_warnings(func_debug, 0);
     }

 #ifndef _FUNC_INCLUDE_WINDOWS_SUPPORT_H
     if (func_debug->is_gzip && func_debug->func_debug_file)
     {
         pclose(func_debug->func_debug_file);
         func_debug->func_debug_file = NULL;
     }
 #endif

     return 0;
 }

 int func_debug_set_file(func_debug_t* func_debug, const char* filename)
 {
     int filenameLen = strlen(filename);

     // Open the debug output file
     ASSERT(filename != NULL);
 #ifndef _FUNC_INCLUDE_WINDOWS_SUPPORT_H
     if (filenameLen > 3 && strcmp(filename + filenameLen - 3, ".gz") == 0)
     {
         char cmd[256];

         snprintf(cmd, sizeof(cmd), "gzip > %s", filename);
         func_debug->func_debug_file = popen(cmd, "w");
         func_debug->is_gzip         = 1;
     }
     else
     {
 #else
     {
 #endif
         func_debug->func_debug_file = fopen(filename, "w");
     }

     if (!func_debug->func_debug_file)
     {
         perror(NULL);
         FATAL_ERROR("Cannot open debug output file: %s\n", filename);
         return 1;
     }
     if (func_debug->is_output_unbuffered)
     {
         setvbuf(func_debug->func_debug_file, nullptr, _IONBF, 0);
     }

     return 0;
 }

 void func_debug_set_verbosity(func_debug_t* func_debug, const char* str)
 {
     if (!strcasecmp(str, "RESET"))
     {
         func_debug_set_verbosity(func_debug, DEBUG_VERB_NONE);
         return;
     }

     for (size_t i = 0; i < DEBUG_VERBOSITY_COUNT; i++)
     {
         if (!strcasecmp(str, func_debug_verbosity_str_table[i]))
         {
             func_debug_set_verbosity(func_debug, func_debug_verbosity_mask_table[i]);
             return;
         }
     }

     FATAL_ERROR("Invalid debug verbosity: %s", str);
 }

 void func_debug_set_verbosity(func_debug_t* func_debug, const uint32_t verb)
 {
     uint32_t new_mask = verb;

     switch (verb)
     {
         case DEBUG_VERB_NONE:
             new_mask = DEBUG_VERB_NONE;
             break;
         case DEBUG_VERB_INFO:
             new_mask = DEBUG_VERB_INFO;
             break;
         case DEBUG_VERB_IFACE:
             new_mask = DEBUG_VERB_IFACE;
             break;
         case DEBUG_VERB_HIGH:
             new_mask |= DEBUG_VERB_HIGH;
             // Intentional fallthrough
         case DEBUG_VERB_MED:
             new_mask |= DEBUG_VERB_MED;
             // Intentional fallthrough
         case DEBUG_VERB_LOW:
             new_mask |= DEBUG_VERB_LOW;
             new_mask |= DEBUG_VERB_INFO;
             new_mask |= DEBUG_VERB_IFACE;
             break;
     }

     func_debug->func_debug_verbosity = new_mask;
 }

 void func_debug_set_suppress_arch_error_mask(func_debug_t* func_debug, const uint32_t suppress)
 {
     func_debug->func_suppress_arch_error_mask = suppress;
 }

 void func_debug_set_mask(func_debug_t* func_debug, const uint64_t mask)
 {
     if (mask == DEBUG_NONE)
         func_debug->func_debug_mask = mask;
     else
         func_debug->func_debug_mask |= mask;

     // Set a minimum verbosity level
     if (func_debug->func_debug_verbosity == DEBUG_VERB_NONE)
         func_debug->func_debug_verbosity = DEBUG_VERB_INFO;
 }

 void func_debug_set_inst_mask(func_debug_t* func_debug, const char* mask)
 {
     uint64_t val;

     val = strtoul(mask, NULL, 0);

     return func_debug_set_inst_mask(func_debug, val);
 }

 void func_debug_set_inst_mask(func_debug_t* func_debug, const uint64_t mask)
 {
     if (mask == 0)
         func_debug->func_debug_inst_mask = DEBUG_INST_ALL;
     else
         func_debug->func_debug_inst_mask = mask;
 }

 void func_debug_set_mask(func_debug_t* func_debug, const char* str)
 {
     if (!strcasecmp(str, "all"))
     {
         func_debug_set_mask(func_debug, UINT64_MAX - 1);
         return;
     }

     size_t i;
     for (i = 0; i < DEBUG_MASK_COUNT; i++)
     {
         if (!strcasecmp(str, func_debug_mode_str_table[i]))
         {
             func_debug_set_mask(func_debug, 1ULL << i);
             return;
         }
     }

     func_debug_print_masks(stderr);

     FATAL_ERROR("Invalid debug mask: %s", str);
 }

 void func_debug_print_masks(FILE* out)
 {
     uint32_t i;

     fprintf(out, "Available debug masks:\n");

     for (i = 0; i < DEBUG_MASK_COUNT; i++)
     {
         fprintf(out, "[%d] %s\n", i, func_debug_mode_str_table[i]);
     }
 }

 void func_debug_set_output_unbuffered(func_debug_t* func_debug, const bool is_unbuffered)
 {
     func_debug->is_output_unbuffered = is_unbuffered;
 }

 // Print warnings to the debug file or optionally store them in a buffer instead
 // Note that the buffer is circular and can be overwritten if enough messages are
 // written before removing a warning from the front.
 void func_debug_warning(
     func_debug_t* func_debug, const char* file, const char* func, const int line, const char* fmt, ...)
 {
     va_list args;
     va_start(args, fmt);

     if (func_debug->record_warnings)
     {
         // Record to the circular buffer
         uint32_t len;

         len = snprintf(func_debug->warning_buffer[func_debug->warning_buffer_tail], WARNING_BUFFER_ENTRY_LENGTH,
                        "WARNING AT %s:%d %s(): ", file, line, func);
         vsnprintf(func_debug->warning_buffer[func_debug->warning_buffer_tail] + len, WARNING_BUFFER_ENTRY_LENGTH - len,
                   fmt, args);
         func_debug->warning_buffer_tail = (func_debug->warning_buffer_tail + 1) % WARNING_BUFFER_SIZE;
     }
     else
     {
         // Print to the debug file (e.g., stderr)
         fprintf(func_debug->func_debug_file, "WARNING AT %s:%d %s():\n", file, line, func);
         vfprintf(func_debug->func_debug_file, fmt, args);
         fprintf(func_debug->func_debug_file, "\n");
     }
     va_end(args);
 }

 // Initialize the warning buffer capture
 int func_debug_set_captured_warnings(func_debug_t* func_debug, uint32_t capture)
 {
     uint32_t i;
     func_debug->record_warnings = capture;
     if (capture)
     {
         func_debug->warning_buffer_head = 0;
         func_debug->warning_buffer_tail = 0;

         for (i = 0; i < WARNING_BUFFER_SIZE; i++)
         {
             func_debug->warning_buffer[i] = (char*)calloc(1, WARNING_BUFFER_ENTRY_LENGTH);
         }
     }
     else
     {
         for (i = 0; i < WARNING_BUFFER_SIZE; i++)
         {
             if (func_debug->warning_buffer[i])
             {
                 free(func_debug->warning_buffer[i]);
                 func_debug->warning_buffer[i] = NULL;
             }
         }
     }

     return 0;
 }

 int func_debug_has_captured_warning(func_debug_t* func_debug)
 {
     if (func_debug->record_warnings && func_debug->warning_buffer_head != func_debug->warning_buffer_tail)
         return 1;
     else
         return 0;
 }

 int func_debug_get_captured_warning(func_debug_t* func_debug, char* buf_ptr, const uint32_t buf_len)
 {
     if (!func_debug_has_captured_warning(func_debug))
         return 1;

     strncpy(buf_ptr, func_debug->warning_buffer[func_debug->warning_buffer_head], buf_len);

     func_debug->warning_buffer_head = (func_debug->warning_buffer_head + 1) % WARNING_BUFFER_SIZE;

     return 0;
 }

	// Copyright (c) 2020, ARM Limited.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include <ctype.h>
	#include <signal.h>
	#include <stdarg.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <sys/types.h>

	#ifndef _MSC_VER
	#include <execinfo.h>
	#include <sys/prctl.h>
	#include <sys/ptrace.h>
	#include <sys/wait.h>
	#include <unistd.h>
	#endif

	#include "func_debug.h"

	#define MAX_FRAMES 100

	#ifndef _MSC_VER
	pid_t func_print_backtrace_helper(int num_tries, int sig);
	#endif

	void func_print_backtrace(FILE* out, int sig)
	{
	#ifndef _MSC_VER
	for (int i = 0; i < 2; i++)
	{
	const pid_t child_pid = func_print_backtrace_helper(i, sig);
	if (child_pid < 0)
	{
	perror("Backtrace generation failed on fork");
	break;
	}

	int status = 0;
	waitpid(child_pid, &status, 0);
	if (WEXITSTATUS(status) == 0)
	{
	break;
	}
	}
	#endif
	}

	#ifndef _MSC_VER
	pid_t func_print_backtrace_helper(int num_tries, int sig)
	{
	const pid_t child_pid = fork();

	if (child_pid)
	{
	return 0;
	}

	const pid_t ppid = getppid();

	printf("Attaching debugger to pid %d\n", ppid);
	// Check if we're in a debugger
	if (ptrace(PTRACE_ATTACH, ppid, 0, 0) == 0)
	{
	// If we reach this point, no debugger is present
	// Undo effects of PTRACE_ATTACH
	waitpid(ppid, NULL, 0);
	ptrace(PTRACE_CONT, 0, 0, 0);
	ptrace(PTRACE_DETACH, ppid, 0, 0);

	dup2(STDERR_FILENO, STDOUT_FILENO);

	char parent_pid[20];
	snprintf(parent_pid, sizeof(parent_pid), "attach %d", ppid);
	fprintf(stdout, "Caught signal %d (%s)\n", sig, strsignal(sig));

	execlp("gdb", "gdb", "--batch", "-n", "-ex",
	// Don't print startup messages for each thread
	"-ex", "set print thread-events off", "-ex", parent_pid,
	// Turn off pagination
	"-ex", "set height 0",
	// Print a backtrace for the current thread
	"-ex", "thread $_thread", "-ex", "bt",
	// Print a backtrace for the main thread (uncomment the next two lines, if desired)
	//"-ex", "thread 1",
	//"-ex", "bt",
	// Print a backtrace for all thread (TMI)
	//"-ex", "thread apply all bt",
	NULL);

	// If we reach this point, it is bad. Attempt to print an error before exiting.
	perror("Backtrace generation failed to invoke gdb");
	exit(1);
	}

	// Debugger present. Exit here.
	exit(0);

	return 0;
	}
	#endif

	void func_backtrace_signal_handler(int sig)
	{
	func_print_backtrace(NULL, sig);
	exit(1);
	}

	// Note: this overwrites other signal handlers. May want to make this
	// more friendly sometime
	void func_enable_signal_handlers()
	{
	static const int sig_list[] = { SIGABRT, SIGSEGV, SIGILL, SIGFPE };

	if (getenv("FUNC_NO_SIG_HANDLERS"))
	{
	return;
	}

	for (size_t i = 0; i < sizeof(sig_list) / sizeof(int); i++)
	{
	struct sigaction act;

	bzero(&act, sizeof(act));
	act.sa_handler = func_backtrace_signal_handler;

	if (sigaction(sig_list[i], &act, NULL))
	{
	perror("Error calling sigaction");
	}
	}
	}

	const char* func_debug_mode_str_table[] = {
	#define DEBUG_MODE(NAME, BIT) #NAME,
	#include "debug_modes.def"
	#undef DEBUG_MODE
	};

	#define DEBUG_MASK_COUNT (sizeof(func_debug_mode_str_table) / sizeof(const char*))

	const char* func_debug_verbosity_str_table[] = { "NONE", "INFO", "IFACE", "LOW", "MED", "HIGH" };

	const uint32_t func_debug_verbosity_mask_table[] = { DEBUG_VERB_NONE, DEBUG_VERB_INFO, DEBUG_VERB_IFACE,
	DEBUG_VERB_LOW, DEBUG_VERB_MED, DEBUG_VERB_HIGH };

	#define DEBUG_VERBOSITY_COUNT (sizeof(func_debug_verbosity_str_table) / sizeof(const char*))

	// Initialize the debug mode
	int func_init_debug(func_debug_t* func_debug, uint64_t inst_id)
	{
	// Set the default debug settings
	bzero(func_debug, sizeof(func_debug_t));
	func_debug_set_mask(func_debug, DEBUG_NONE);
	func_debug_set_verbosity(func_debug, DEBUG_VERB_NONE);
	func_debug_set_inst_mask(func_debug, DEBUG_INST_ALL);
	func_debug->func_debug_file = stderr;
	func_debug_set_captured_warnings(func_debug, 0);
	func_debug_set_output_unbuffered(func_debug, false);
	func_debug->inst_id = inst_id;

	return 0;
	}

	int func_fini_debug(func_debug_t* func_debug)
	{
	if (func_debug->record_warnings)
	{
	func_debug_set_captured_warnings(func_debug, 0);
	}

	#ifndef _FUNC_INCLUDE_WINDOWS_SUPPORT_H
	if (func_debug->is_gzip && func_debug->func_debug_file)
	{
	pclose(func_debug->func_debug_file);
	func_debug->func_debug_file = NULL;
	}
	#endif

	return 0;
	}

	int func_debug_set_file(func_debug_t* func_debug, const char* filename)
	{
	int filenameLen = strlen(filename);

	// Open the debug output file
	ASSERT(filename != NULL);
	#ifndef _FUNC_INCLUDE_WINDOWS_SUPPORT_H
	if (filenameLen > 3 && strcmp(filename + filenameLen - 3, ".gz") == 0)
	{
	char cmd[256];

	snprintf(cmd, sizeof(cmd), "gzip > %s", filename);
	func_debug->func_debug_file = popen(cmd, "w");
	func_debug->is_gzip = 1;
	}
	else
	{
	#else
	{
	#endif
	func_debug->func_debug_file = fopen(filename, "w");
	}

	if (!func_debug->func_debug_file)
	{
	perror(NULL);
	FATAL_ERROR("Cannot open debug output file: %s\n", filename);
	return 1;
	}
	if (func_debug->is_output_unbuffered)
	{
	setvbuf(func_debug->func_debug_file, nullptr, _IONBF, 0);
	}

	return 0;
	}

	void func_debug_set_verbosity(func_debug_t* func_debug, const char* str)
	{
	if (!strcasecmp(str, "RESET"))
	{
	func_debug_set_verbosity(func_debug, DEBUG_VERB_NONE);
	return;
	}

	for (size_t i = 0; i < DEBUG_VERBOSITY_COUNT; i++)
	{
	if (!strcasecmp(str, func_debug_verbosity_str_table[i]))
	{
	func_debug_set_verbosity(func_debug, func_debug_verbosity_mask_table[i]);
	return;
	}
	}

	FATAL_ERROR("Invalid debug verbosity: %s", str);
	}

	void func_debug_set_verbosity(func_debug_t* func_debug, const uint32_t verb)
	{
	uint32_t new_mask = verb;

	switch (verb)
	{
	case DEBUG_VERB_NONE:
	new_mask = DEBUG_VERB_NONE;
	break;
	case DEBUG_VERB_INFO:
	new_mask = DEBUG_VERB_INFO;
	break;
	case DEBUG_VERB_IFACE:
	new_mask = DEBUG_VERB_IFACE;
	break;
	case DEBUG_VERB_HIGH:
	new_mask \|= DEBUG_VERB_HIGH;
	// Intentional fallthrough
	case DEBUG_VERB_MED:
	new_mask \|= DEBUG_VERB_MED;
	// Intentional fallthrough
	case DEBUG_VERB_LOW:
	new_mask \|= DEBUG_VERB_LOW;
	new_mask \|= DEBUG_VERB_INFO;
	new_mask \|= DEBUG_VERB_IFACE;
	break;
	}

	func_debug->func_debug_verbosity = new_mask;
	}

	void func_debug_set_suppress_arch_error_mask(func_debug_t* func_debug, const uint32_t suppress)
	{
	func_debug->func_suppress_arch_error_mask = suppress;
	}

	void func_debug_set_mask(func_debug_t* func_debug, const uint64_t mask)
	{
	if (mask == DEBUG_NONE)
	func_debug->func_debug_mask = mask;
	else
	func_debug->func_debug_mask \|= mask;

	// Set a minimum verbosity level
	if (func_debug->func_debug_verbosity == DEBUG_VERB_NONE)
	func_debug->func_debug_verbosity = DEBUG_VERB_INFO;
	}

	void func_debug_set_inst_mask(func_debug_t* func_debug, const char* mask)
	{
	uint64_t val;

	val = strtoul(mask, NULL, 0);

	return func_debug_set_inst_mask(func_debug, val);
	}

	void func_debug_set_inst_mask(func_debug_t* func_debug, const uint64_t mask)
	{
	if (mask == 0)
	func_debug->func_debug_inst_mask = DEBUG_INST_ALL;
	else
	func_debug->func_debug_inst_mask = mask;
	}

	void func_debug_set_mask(func_debug_t* func_debug, const char* str)
	{
	if (!strcasecmp(str, "all"))
	{
	func_debug_set_mask(func_debug, UINT64_MAX - 1);
	return;
	}

	size_t i;
	for (i = 0; i < DEBUG_MASK_COUNT; i++)
	{
	if (!strcasecmp(str, func_debug_mode_str_table[i]))
	{
	func_debug_set_mask(func_debug, 1ULL << i);
	return;
	}
	}

	func_debug_print_masks(stderr);

	FATAL_ERROR("Invalid debug mask: %s", str);
	}

	void func_debug_print_masks(FILE* out)
	{
	uint32_t i;

	fprintf(out, "Available debug masks:\n");

	for (i = 0; i < DEBUG_MASK_COUNT; i++)
	{
	fprintf(out, "[%d] %s\n", i, func_debug_mode_str_table[i]);
	}
	}

	void func_debug_set_output_unbuffered(func_debug_t* func_debug, const bool is_unbuffered)
	{
	func_debug->is_output_unbuffered = is_unbuffered;
	}

	// Print warnings to the debug file or optionally store them in a buffer instead
	// Note that the buffer is circular and can be overwritten if enough messages are
	// written before removing a warning from the front.
	void func_debug_warning(
	func_debug_t* func_debug, const char* file, const char* func, const int line, const char* fmt, ...)
	{
	va_list args;
	va_start(args, fmt);

	if (func_debug->record_warnings)
	{
	// Record to the circular buffer
	uint32_t len;

	len = snprintf(func_debug->warning_buffer[func_debug->warning_buffer_tail], WARNING_BUFFER_ENTRY_LENGTH,
	"WARNING AT %s:%d %s(): ", file, line, func);
	vsnprintf(func_debug->warning_buffer[func_debug->warning_buffer_tail] + len, WARNING_BUFFER_ENTRY_LENGTH - len,
	fmt, args);
	func_debug->warning_buffer_tail = (func_debug->warning_buffer_tail + 1) % WARNING_BUFFER_SIZE;
	}
	else
	{
	// Print to the debug file (e.g., stderr)
	fprintf(func_debug->func_debug_file, "WARNING AT %s:%d %s():\n", file, line, func);
	vfprintf(func_debug->func_debug_file, fmt, args);
	fprintf(func_debug->func_debug_file, "\n");
	}
	va_end(args);
	}

	// Initialize the warning buffer capture
	int func_debug_set_captured_warnings(func_debug_t* func_debug, uint32_t capture)
	{
	uint32_t i;
	func_debug->record_warnings = capture;
	if (capture)
	{
	func_debug->warning_buffer_head = 0;
	func_debug->warning_buffer_tail = 0;

	for (i = 0; i < WARNING_BUFFER_SIZE; i++)
	{
	func_debug->warning_buffer[i] = (char*)calloc(1, WARNING_BUFFER_ENTRY_LENGTH);
	}
	}
	else
	{
	for (i = 0; i < WARNING_BUFFER_SIZE; i++)
	{
	if (func_debug->warning_buffer[i])
	{
	free(func_debug->warning_buffer[i]);
	func_debug->warning_buffer[i] = NULL;
	}
	}
	}

	return 0;
	}

	int func_debug_has_captured_warning(func_debug_t* func_debug)
	{
	if (func_debug->record_warnings && func_debug->warning_buffer_head != func_debug->warning_buffer_tail)
	return 1;
	else
	return 0;
	}

	int func_debug_get_captured_warning(func_debug_t* func_debug, char* buf_ptr, const uint32_t buf_len)
	{
	if (!func_debug_has_captured_warning(func_debug))
	return 1;

	strncpy(buf_ptr, func_debug->warning_buffer[func_debug->warning_buffer_head], buf_len);

	func_debug->warning_buffer_head = (func_debug->warning_buffer_head + 1) % WARNING_BUFFER_SIZE;

	return 0;
	}