kevin/neovim
1
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2024-12-23 20:55:18 -07:00
Code Issues Packages Projects Releases Wiki Activity

build: remove LOG_LIST_ACTIONS option and related code

Browse Source 
It has not been used for a long time and the likelihood of it working
isn't high.
This commit is contained in:
dundargoc 2023-05-26 14:55:34 +02:00
parent 03a2c5b772
commit 5100fe263f
7 changed files with 0 additions and 183 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -146,8 +146,6 @@ if(CMAKE_C_FLAGS_RELWITHDEBINFO MATCHES DNDEBUG)
string(REPLACE " " " " CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO}") # Remove duplicate whitespace
endif()
option(LOG_LIST_ACTIONS "Add list actions logging" OFF)
option(ENABLE_ASAN_UBSAN "Enable Clang address & undefined behavior sanitizer for nvim binary." OFF)
option(LOG_DEBUG "Enable debug log messages even in a release build" OFF)
option(ENABLE_MSAN "Enable Clang memory sanitizer for nvim binary." OFF)

4
cmake.config/config.h.in
View File

@ -45,10 +45,6 @@
#cmakedefine HAVE_DIRFD_AND_FLOCK
#cmakedefine HAVE_FORKPTY
#ifndef UNIT_TESTING
#cmakedefine LOG_LIST_ACTIONS
#endif
#cmakedefine HAVE_BE64TOH
#cmakedefine ORDER_BIG_ENDIAN
#define ENDIAN_INCLUDE_FILE <@ENDIAN_INCLUDE_FILE@>

80
src/nvim/eval/typval.c
View File

@ -82,70 +82,6 @@ bool tv_in_free_unref_items = false;
const char *const tv_empty_string = "";
//{{{1 Lists
//{{{2 List log
#ifdef LOG_LIST_ACTIONS
ListLog *list_log_first = NULL;
ListLog *list_log_last = NULL;
/// Write list log to the given file
///
/// @param[in] fname File to write log to. Will be appended to if already
/// present.
void list_write_log(const char *const fname)
FUNC_ATTR_NONNULL_ALL
{
FileDescriptor fp;
const int fo_ret = file_open(&fp, fname, kFileCreate|kFileAppend, 0600);
if (fo_ret != 0) {
semsg(_("E5142: Failed to open file %s: %s"), fname, os_strerror(fo_ret));
return;
}
for (ListLog *chunk = list_log_first; chunk != NULL;) {
for (size_t i = 0; i < chunk->size; i++) {
char buf[10 + 1 + ((16 + 3) * 3) + (8 + 2) + 2];
// act : hex " c:" len "[]" "\n\0"
const ListLogEntry entry = chunk->entries[i];
const size_t snp_len = (size_t)snprintf(buf, sizeof(buf),
"%-10.10s: l:%016" PRIxPTR "[%08d] 1:%016" PRIxPTR " 2:%016" PRIxPTR
"\n",
entry.action, entry.l, entry.len, entry.li1,
entry.li2);
assert(snp_len + 1 == sizeof(buf));
const ptrdiff_t fw_ret = file_write(&fp, buf, snp_len);
if (fw_ret != (ptrdiff_t)snp_len) {
assert(fw_ret < 0);
if (i) {
memmove(chunk->entries, chunk->entries + i,
sizeof(chunk->entries[0]) * (chunk->size - i));
chunk->size -= i;
}
semsg(_("E5143: Failed to write to file %s: %s"),
fname, os_strerror((int)fw_ret));
return;
}
}
list_log_first = chunk->next;
xfree(chunk);
chunk = list_log_first;
}
const int fc_ret = file_close(&fp, true);
if (fc_ret != 0) {
semsg(_("E5144: Failed to close file %s: %s"), fname, os_strerror(fc_ret));
}
}
# ifdef EXITFREE
/// Free list log
void list_free_log(void)
{
for (ListLog *chunk = list_log_first; chunk != NULL;) {
list_log_first = chunk->next;
xfree(chunk);
chunk = list_log_first;
}
}
# endif
#endif
//{{{2 List item
/// Allocate a list item
@ -252,7 +188,6 @@ list_T *tv_list_alloc(const ptrdiff_t len)
list->lv_used_prev = NULL;
list->lv_used_next = gc_first_list;
gc_first_list = list;
list_log(list, NULL, (void *)(uintptr_t)len, "alloc");
list->lua_table_ref = LUA_NOREF;
return list;
}
@ -283,8 +218,6 @@ void tv_list_init_static10(staticList10_T *const sl)
li->li_prev = li - 1;
li->li_next = li + 1;
}
list_log((const list_T *)sl, &sl->sl_items[0], &sl->sl_items[SL_SIZE - 1],
"s10init");
#undef SL_SIZE
}
@ -296,7 +229,6 @@ void tv_list_init_static(list_T *const l)
{
CLEAR_POINTER(l);
l->lv_refcount = DO_NOT_FREE_CNT;
list_log(l, NULL, NULL, "sinit");
}
/// Free items contained in a list
@ -305,7 +237,6 @@ void tv_list_init_static(list_T *const l)
void tv_list_free_contents(list_T *const l)
FUNC_ATTR_NONNULL_ALL
{
list_log(l, NULL, NULL, "freecont");
for (listitem_T *item = l->lv_first; item != NULL; item = l->lv_first) {
// Remove the item before deleting it.
l->lv_first = item->li_next;
@ -335,7 +266,6 @@ void tv_list_free_list(list_T *const l)
if (l->lv_used_next != NULL) {
l->lv_used_next->lv_used_prev = l->lv_used_prev;
}
list_log(l, NULL, NULL, "freelist");
NLUA_CLEAR_REF(l->lua_table_ref);
xfree(l);
@ -382,7 +312,6 @@ void tv_list_unref(list_T *const l)
void tv_list_drop_items(list_T *const l, listitem_T *const item, listitem_T *const item2)
FUNC_ATTR_NONNULL_ALL
{
list_log(l, item, item2, "drop");
// Notify watchers.
for (listitem_T *ip = item; ip != item2->li_next; ip = ip->li_next) {
l->lv_len--;
@ -400,14 +329,12 @@ void tv_list_drop_items(list_T *const l, listitem_T *const item, listitem_T *con
item->li_prev->li_next = item2->li_next;
}
l->lv_idx_item = NULL;
list_log(l, l->lv_first, l->lv_last, "afterdrop");
}
/// Like tv_list_drop_items, but also frees all removed items
void tv_list_remove_items(list_T *const l, listitem_T *const item, listitem_T *const item2)
FUNC_ATTR_NONNULL_ALL
{
list_log(l, item, item2, "remove");
tv_list_drop_items(l, item, item2);
for (listitem_T *li = item;;) {
tv_clear(TV_LIST_ITEM_TV(li));
@ -431,7 +358,6 @@ void tv_list_move_items(list_T *const l, listitem_T *const item, listitem_T *con
list_T *const tgt_l, const int cnt)
FUNC_ATTR_NONNULL_ALL
{
list_log(l, item, item2, "move");
tv_list_drop_items(l, item, item2);
item->li_prev = tgt_l->lv_last;
item2->li_next = NULL;
@ -442,7 +368,6 @@ void tv_list_move_items(list_T *const l, listitem_T *const item, listitem_T *con
}
tgt_l->lv_last = item2;
tgt_l->lv_len += cnt;
list_log(tgt_l, tgt_l->lv_first, tgt_l->lv_last, "movetgt");
}
/// Insert list item
@ -470,7 +395,6 @@ void tv_list_insert(list_T *const l, listitem_T *const ni, listitem_T *const ite
}
item->li_prev = ni;
l->lv_len++;
list_log(l, ni, item, "insert");
}
}
@ -496,7 +420,6 @@ void tv_list_insert_tv(list_T *const l, typval_T *const tv, listitem_T *const it
void tv_list_append(list_T *const l, listitem_T *const item)
FUNC_ATTR_NONNULL_ALL
{
list_log(l, item, NULL, "append");
if (l->lv_last == NULL) {
// empty list
l->lv_first = item;
@ -1416,7 +1339,6 @@ void tv_list_reverse(list_T *const l)
if (tv_list_len(l) <= 1) {
return;
}
list_log(l, NULL, NULL, "reverse");
#define SWAP(a, b) \
do { \
tmp = (a); \
@ -1454,7 +1376,6 @@ void tv_list_item_sort(list_T *const l, ListSortItem *const ptrs,
if (len <= 1) {
return;
}
list_log(l, NULL, NULL, "sort");
int i = 0;
TV_LIST_ITER(l, li, {
ptrs[i].item = li;
@ -1543,7 +1464,6 @@ listitem_T *tv_list_find(list_T *const l, int n)
// Cache the used index.
l->lv_idx = idx;
l->lv_idx_item = item;
list_log(l, l->lv_idx_item, (void *)(uintptr_t)l->lv_idx, "find");
return item;
}

74
src/nvim/eval/typval.h
View File

@ -18,74 +18,6 @@
#include "nvim/message.h"
#include "nvim/types.h"
#ifdef LOG_LIST_ACTIONS
# include "nvim/memory.h"
extern ListLog *list_log_first; ///< First list log chunk, NULL if missing
extern ListLog *list_log_last; ///< Last list log chunk
static inline ListLog *list_log_alloc(const size_t size)
REAL_FATTR_ALWAYS_INLINE REAL_FATTR_WARN_UNUSED_RESULT;
/// Allocate a new log chunk and update globals
///
/// @param[in] size Number of entries in a new chunk.
///
/// @return [allocated] Newly allocated chunk.
static inline ListLog *list_log_new(const size_t size)
{
ListLog *ret = xmalloc(offsetof(ListLog, entries)
+ size * sizeof(ret->entries[0]));
ret->size = 0;
ret->capacity = size;
ret->next = NULL;
if (list_log_first == NULL) {
list_log_first = ret;
} else {
list_log_last->next = ret;
}
list_log_last = ret;
return ret;
}
static inline void list_log(const list_T *const l, const listitem_T *const li1,
const listitem_T *const li2, const char *const action)
REAL_FATTR_ALWAYS_INLINE;
/// Add new entry to log
///
/// If last chunk was filled it uses twice as much memory to allocate the next
/// chunk.
///
/// @param[in] l List to which entry belongs.
/// @param[in] li1 List item 1.
/// @param[in] li2 List item 2, often used for integers and not list items.
/// @param[in] action Logged action.
static inline void list_log(const list_T *const l, const listitem_T *const li1,
const listitem_T *const li2, const char *const action)
{
ListLog *tgt;
if (list_log_first == NULL) {
tgt = list_log_new(128);
} else if (list_log_last->size == list_log_last->capacity) {
tgt = list_log_new(list_log_last->capacity * 2);
} else {
tgt = list_log_last;
}
tgt->entries[tgt->size++] = (ListLogEntry) {
.l = (uintptr_t)l,
.li1 = (uintptr_t)li1,
.li2 = (uintptr_t)li2,
.len = (l == NULL ? 0 : l->lv_len),
.action = action,
};
}
#else
# define list_log(...)
# define list_write_log(...)
# define list_free_log()
#endif
// In a hashtab item "hi_key" points to "di_key" in a dictitem.
// This avoids adding a pointer to the hashtab item.
@ -174,7 +106,6 @@ static inline int tv_list_len(const list_T *l)
/// @param[in] l List to check.
static inline int tv_list_len(const list_T *const l)
{
list_log(l, NULL, NULL, "len");
if (l == NULL) {
return 0;
}
@ -258,10 +189,8 @@ static inline listitem_T *tv_list_first(const list_T *l)
static inline listitem_T *tv_list_first(const list_T *const l)
{
if (l == NULL) {
list_log(l, NULL, NULL, "first");
return NULL;
}
list_log(l, l->lv_first, NULL, "first");
return l->lv_first;
}
@ -276,10 +205,8 @@ static inline listitem_T *tv_list_last(const list_T *l)
static inline listitem_T *tv_list_last(const list_T *const l)
{
if (l == NULL) {
list_log(l, NULL, NULL, "last");
return NULL;
}
list_log(l, l->lv_last, NULL, "last");
return l->lv_last;
}
@ -416,7 +343,6 @@ extern bool tv_in_free_unref_items;
#define _TV_LIST_ITER_MOD(modifier, l, li, code) \
do { \
modifier list_T *const l_ = (l); \
list_log(l_, NULL, NULL, "iter" #modifier); \
if (l_ != NULL) { \
for (modifier listitem_T *li = l_->lv_first; \
li != NULL; li = li->li_next) { \

21
src/nvim/eval/typval_defs.h
View File

@ -375,25 +375,4 @@ typedef struct {
typedef int (*ListSorter)(const void *, const void *);
#ifdef LOG_LIST_ACTIONS
/// List actions log entry
typedef struct {
uintptr_t l; ///< List log entry belongs to.
uintptr_t li1; ///< First list item log entry belongs to, if applicable.
uintptr_t li2; ///< Second list item log entry belongs to, if applicable.
int len; ///< List length when log entry was created.
const char *action; ///< Logged action.
} ListLogEntry;
typedef struct list_log ListLog;
/// List actions log
struct list_log {
ListLog *next; ///< Next chunk or NULL.
size_t capacity; ///< Number of entries in current chunk.
size_t size; ///< Current chunk size.
ListLogEntry entries[]; ///< Actual log entries.
};
#endif
#endif // NVIM_EVAL_TYPVAL_DEFS_H

1
src/nvim/memory.c
View File

@ -816,7 +816,6 @@ void free_all_mem(void)
grid_free_all_mem();
clear_hl_tables(false);
list_free_log();
check_quickfix_busy();

1
src/nvim/testing.c
View File

@ -775,5 +775,4 @@ void f_test_write_list_log(typval_T *const argvars, typval_T *const rettv, EvalF
if (fname == NULL) {
return;
}
list_write_log(fname);
}