Subversion Repositories riscv_vhdl

/*

 *  Copyright 2018 Sergey Khabarov, sergeykhbr@gmail.com

 *

 *  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.

 */

#ifndef __DEBUGGER_API_UTILS_H__

#define __DEBUGGER_API_UTILS_H__

#include <stdarg.h>

#include <api_types.h>

#include <attribute.h>

namespace debugger {

#define LOG_ERROR     1

#define LOG_IMPORTANT 2   // can be used for the autotest messages

#define LOG_INFO      3

#define LOG_DEBUG     4

#ifdef __cplusplus

extern "C" {

#endif

/** Generate unique string. */

void RISCV_generate_name(AttributeType *name);

/** Redirect output to specified console. */

void RISCV_add_default_output(void *iout);

void RISCV_remove_default_output(void *iout);

/**

 * @brief Write output to logfile.

 * @return 0 on success, 1 when failed

 */

int RISCV_enable_log(const char *filename);

void RISCV_disable_log();

/** Format output to string. */

int RISCV_sprintf(char *s, size_t len, const char *fmt, ...);

/** Format output to the default stream. */

int RISCV_printf(void *iface, int level, const char *fmt, ...);

/** Output always */

#define RISCV_printf0(fmt, ...) \

    RISCV_printf(getInterface(IFACE_SERVICE), 0, fmt, __VA_ARGS__)

/** Output with the maximal logging level */

#define RISCV_error(fmt, ...) \

    RISCV_printf(getInterface(IFACE_SERVICE), LOG_ERROR, "%s:%d " fmt, \

                 __FILE__, __LINE__, __VA_ARGS__)

/** Output with the information logging level */

#define RISCV_important(fmt, ...) \

    RISCV_printf(getInterface(IFACE_SERVICE), LOG_IMPORTANT, fmt, __VA_ARGS__)

/** Output with the information logging level */

#define RISCV_info(fmt, ...) \

    RISCV_printf(getInterface(IFACE_SERVICE), LOG_INFO, fmt, __VA_ARGS__)

/** Output with the lower logging level */

#define RISCV_debug(fmt, ...) \

    RISCV_printf(getInterface(IFACE_SERVICE), LOG_DEBUG, fmt, __VA_ARGS__)

/** Suspend thread on certain number of milliseconds */

void RISCV_sleep_ms(int ms);

/** Get current time in milliseconds. */

uint64_t RISCV_get_time_ms();

/** Get process ID. */

int RISCV_get_pid();

/** Memory barrier */

void RISCV_memory_barrier();

void RISCV_thread_create(void *data);

uint64_t RISCV_thread_id();

int RISCV_mutex_init(mutex_def *mutex);

int RISCV_mutex_lock(mutex_def *mutex);

int RISCV_mutex_unlock(mutex_def *mutex);

int RISCV_mutex_destroy(mutex_def *mutex);

void RISCV_thread_join(thread_def th, int ms);

void RISCV_event_create(event_def *ev, const char *name);

void RISCV_event_close(event_def *ev);

void RISCV_event_set(event_def *ev);

int RISCV_event_is_set(event_def *ev);

void RISCV_event_clear(event_def *ev);

void RISCV_event_wait(event_def *ev);

int RISCV_event_wait_ms(event_def *ev, int ms);

sharemem_def RISCV_memshare_create(const char *name, int sz);

void* RISCV_memshare_map(sharemem_def h, int sz);

void RISCV_memshare_unmap(void *buf);

void RISCV_memshare_delete(sharemem_def h);

/** Memory allocator/de-allocator */

void *RISCV_malloc(uint64_t sz);

void RISCV_free(void *p);

/** Get absolute directory where core library is placed. */

int RISCV_get_core_folder(char *out, int sz);

/** Set $(pwd) directory equals to executable location */

void RISCV_set_current_dir();

/** Reading configuration from JSON formatted file. */

int RISCV_read_json_file(const char *filename, void *outattr);

/** Write configuration string to JSON formatted file. */

void RISCV_write_json_file(const char *filename, const char *s);

#ifdef __cplusplus

}

#endif

}  // namespace debugger

#endif  // __DEBUGGER_API_UTILS_H__