From 3da8e221b218bed7bed0e2acd941e7c3ad29d329 Mon Sep 17 00:00:00 2001 From: "yu.dongliang" <18588496441@163.com> Date: Mon, 11 Nov 2024 14:01:07 +0800 Subject: [PATCH] 1, merge 'coroutine' to scf core framework, 2, close some logs, 3, fix: x64 integer register & float register No. conflict --- core/scf_operator_handler_3ac.c | 14 ++ coroutine/Makefile | 7 +- coroutine/main.c | 72 +++++++++ coroutine/scf_coroutine.c | 226 ++++++++++++++++++++--------- coroutine/scf_coroutine.h | 21 ++- coroutine/scf_coroutine_asm.S | 78 +++++++++- coroutine/scf_coroutine_run.c | 13 +- elf/scf_elf_arm32.c | 18 +-- elf/scf_elf_arm32_so.c | 24 +-- elf/scf_elf_arm64.c | 4 +- elf/scf_elf_arm64_so.c | 18 +-- elf/scf_elf_naja.c | 4 +- elf/scf_elf_naja_so.c | 18 +-- elf/scf_elf_native32.c | 12 +- elf/scf_elf_x64_so.c | 7 +- examples/coroutine_printf.c | 15 ++ examples/init_array_reshape.c | 25 ++++ native/risc/scf_risc.c | 4 +- native/risc/scf_risc_inst.c | 8 +- native/x64/scf_x64.c | 2 +- native/x64/scf_x64_reg.c | 28 ++-- parse/main.c | 13 +- parse/scf_dfa_async.c | 50 +++++-- parse/scf_operator_handler_const.c | 17 ++- parse/scf_struct_array.c | 115 ++++++++++++--- util/scf_rbtree.c | 1 - vm/scf_vm_naja.c | 18 +-- 27 files changed, 617 insertions(+), 215 deletions(-) create mode 100644 coroutine/main.c create mode 100644 examples/coroutine_printf.c create mode 100644 examples/init_array_reshape.c diff --git a/core/scf_operator_handler_3ac.c b/core/scf_operator_handler_3ac.c index 297aaee..cbaf8fe 100644 --- a/core/scf_operator_handler_3ac.c +++ b/core/scf_operator_handler_3ac.c @@ -1492,6 +1492,7 @@ static int _scf_op_call(scf_ast_t* ast, scf_node_t** nodes, int nb_nodes, void* scf_handler_data_t* d = data; scf_variable_t* v = NULL; + scf_variable_t* fmt = NULL; scf_function_t* f = NULL; scf_vector_t* argv = NULL; scf_node_t* parent = nodes[0]->parent; @@ -1561,6 +1562,19 @@ static int _scf_op_call(scf_ast_t* ast, scf_node_t** nodes, int nb_nodes, void* && !v->local_flag && !v->const_flag) v->tmp_flag = 1; + + if (!strcmp(f->node.w->text->data, "scf_async") && i > 2) { + + fmt = _scf_operand_get(nodes[2]); + + if (scf_variable_float(v)) + ret = scf_string_cat_cstr_len(fmt->data.s, "f", 1); + else + ret = scf_string_cat_cstr_len(fmt->data.s, "d", 1); + + if (ret < 0) + return ret; + } } if (parent->result_nodes) { diff --git a/coroutine/Makefile b/coroutine/Makefile index ec4dc2e..3db3a91 100644 --- a/coroutine/Makefile +++ b/coroutine/Makefile @@ -1,13 +1,14 @@ CFILES += ../util/scf_rbtree.c CFILES += scf_coroutine.c CFILES += scf_coroutine_run.c +#CFILES += main.c CFILES += scf_coroutine_asm.S -CFILES += scf_coroutine_test.c -CFLAGS += -g -O3 -no-pie +CFLAGS += -g -O3 -fPIC -shared CFLAGS += -I../util LDFLAGS += all: - gcc $(CFLAGS) $(CFILES) $(LDFLAGS) + gcc $(CFLAGS) $(CFILES) $(LDFLAGS) -o libscf_co.so + gcc -I../util main.c -lscf_co -L./ diff --git a/coroutine/main.c b/coroutine/main.c new file mode 100644 index 0000000..a476a5e --- /dev/null +++ b/coroutine/main.c @@ -0,0 +1,72 @@ +#include"scf_coroutine.h" + +#include +#include +#include +#include + +#include +#include +#include + +static int _async_test() +{ + int fd = socket(AF_INET, SOCK_STREAM, 0); + if (fd < 0) { + scf_loge("\n"); + return -1; + } + + struct sockaddr_in addr; + addr.sin_family = AF_INET; + addr.sin_port = htons(2000); + addr.sin_addr.s_addr = inet_addr("127.0.0.1"); + + int ret = __async_connect(fd, (struct sockaddr*)&addr, sizeof(addr), 1000); + if (ret < 0) { + scf_loge("\n"); + return -1; + } + + ret = __async_write(fd, "hello\n", 7); + if (ret < 0) { + scf_loge("\n"); + return -1; + } + + scf_logi("async test ok, ret: %d\n", ret); + return 0; +} + +int main() +{ + scf_co_thread_t* thread = NULL; + scf_co_task_t* task = NULL; + + int ret = scf_co_thread_open(&thread); + if (ret < 0) { + scf_loge("\n"); + return -1; + } + + uintptr_t rsp[] = {5, 6, 0.1, 7}; + + *(double*)&rsp[2] = 0.123; + +// interger: rdi rsi rdx rcx r8 r9, float / double: xmm0-xmm7, stack rsp: ... + ret = __scf_async((uintptr_t)_async_test, "dddd ffff ffff", 1, 2, 3, 4, rsp, 0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7); + if (ret < 0) { + scf_loge("\n"); + return -1; + } + + scf_logi("thread: %p\n", thread); + + ret = scf_co_thread_run(thread); + if (ret < 0) { + scf_loge("\n"); + return -1; + } + + return 0; +} diff --git a/coroutine/scf_coroutine.c b/coroutine/scf_coroutine.c index 711b0eb..4e23257 100644 --- a/coroutine/scf_coroutine.c +++ b/coroutine/scf_coroutine.c @@ -1,6 +1,6 @@ #include"scf_coroutine.h" -static scf_co_thread_t* co_thread = NULL; +scf_co_thread_t* __co_thread = NULL; int __scf_co_task_run(scf_co_task_t* task); void __asm_co_task_yield(scf_co_task_t* task, uintptr_t* task_rip, uintptr_t* task_rsp, uintptr_t task_rsp0); @@ -31,7 +31,7 @@ int scf_co_thread_open (scf_co_thread_t** pthread) scf_rbtree_init(&thread->timers); scf_list_init (&thread->tasks); - co_thread = thread; + __co_thread = thread; *pthread = thread; return 0; @@ -43,31 +43,118 @@ int scf_co_thread_close(scf_co_thread_t* thread) return -1; } -int scf_co_task_alloc(scf_co_task_t** ptask, uintptr_t func_ptr, uintptr_t rdi, uintptr_t rsi, uintptr_t rdx, uintptr_t rcx) +int scf_co_task_alloc(scf_co_task_t** ptask, uintptr_t funcptr, const char* fmt, uintptr_t rdx, uintptr_t rcx, uintptr_t r8, uintptr_t r9, uintptr_t* rsp, + double xmm0, double xmm1, double xmm2, double xmm3, double xmm4, double xmm5, double xmm6, double xmm7) { scf_co_task_t* task = calloc(1, sizeof(scf_co_task_t)); if (!task) return -ENOMEM; - task->stack_data = calloc(4, sizeof(uintptr_t)); + const char* p; + + int i = 0; + int j = 0; + + scf_logi("fmt: %s\n", fmt); + + for (p = fmt; *p; p++) { + + if ('d'== *p) // 'd' in format string for 'long', 'f' for 'double' + i++; + else if ('f' == *p) + j++; + } + + if (j > 0) + task->n_floats = 1; + else + task->n_floats = 0; + + scf_logi("n_floats: %d\n", task->n_floats); + + i -= 4; // rdx, rcx, r8, r9 not in stack, xmm0-xmm7 too. + j -= 8; + + if (i < 0) + i = 0; + + if (j < 0) + j = 0; + + int n = 6 + 8 + i + j; + int k; + + if (n % 2 == 0) + n++; + + task->stack_data = calloc(n, sizeof(uintptr_t)); if (!task->stack_data) { free(task); return -ENOMEM; } - task->stack_len = 4 * sizeof(uintptr_t); + scf_logi("int: %d, float: %d, n: %d\n", i, j, n); + + task->stack_len = n * sizeof(uintptr_t); + + task->stack_data[0] = rdx; + task->stack_data[1] = rcx; + task->stack_data[2] = r8; + task->stack_data[3] = r9; + + task->stack_data[6] = *(uint64_t*)&xmm0; + task->stack_data[7] = *(uint64_t*)&xmm1; + task->stack_data[8] = *(uint64_t*)&xmm2; + task->stack_data[9] = *(uint64_t*)&xmm3; + task->stack_data[10] = *(uint64_t*)&xmm4; + task->stack_data[11] = *(uint64_t*)&xmm5; + task->stack_data[12] = *(uint64_t*)&xmm6; + task->stack_data[13] = *(uint64_t*)&xmm7; + + i = 0; + j = 0; + k = 0; + n = 14; + for (p = fmt; *p; p++) { + + if ('d'== *p) { + + if (4 == i || 5 == i) + task->stack_data[i] = rsp[k++]; + else if (i >= 6) + task->stack_data[n++] = rsp[k++]; + i++; + + } else if ('f' == *p) { + if (j >= 8) + task->stack_data[n++] = rsp[k++]; + j++; + } + } - uintptr_t* stack = task->stack_data; - stack[0] = rdi; - stack[1] = rsi; - stack[2] = rdx; - stack[3] = rcx; + i = 0; + j = 0; + for (p = fmt; *p; p++) { + + if ('d'== *p) { + scf_logi("d, task->stack[%d]: %#lx\n", i, task->stack_data[i]); + i++; + } else if ('f' == *p) { + if (j >= 8) { + scf_logi("f, task->stack[%d]: %lg\n", i, *(double*)&task->stack_data[i]); + i++; + } + j++; + } + } - scf_loge("rdi: %ld, stack[0]: %ld\n", rdi, stack[0]); + scf_logi("-----------\n"); + for (i = 0; i < task->stack_len / sizeof(uintptr_t); i++) + scf_logi("task->stack[%d]: %#lx\n", i, task->stack_data[i]); task->stack_capacity = task->stack_len; - task->rip = func_ptr; + task->rip = funcptr; *ptask = task; return 0; @@ -85,17 +172,6 @@ static int _co_timer_cmp(scf_rbtree_node_t* node0, void* data) return 0; } -static int _co_timer_cmp_task(scf_rbtree_node_t* node0, void* data) -{ - scf_co_task_t* task0 = (scf_co_task_t*)node0; - scf_co_task_t* task1 = (scf_co_task_t*)data; - - if (task0->time < task1->time) - return -1; - else if (task0->time > task1->time) - return 1; -} - void scf_co_task_free(scf_co_task_t* task) { if (task->stack_data) @@ -104,7 +180,7 @@ void scf_co_task_free(scf_co_task_t* task) free(task); } -int scf_co_thread_add_task(scf_co_thread_t* thread, scf_co_task_t* task) +void scf_co_thread_add_task(scf_co_thread_t* thread, scf_co_task_t* task) { task->time = scf_gettime(); @@ -114,14 +190,14 @@ int scf_co_thread_add_task(scf_co_thread_t* thread, scf_co_task_t* task) task->thread = thread; - thread->nb_tasks++; - return 0; + thread->n_tasks++; } -int scf_async(uintptr_t funcptr, uintptr_t rdi, uintptr_t rsi, uintptr_t rdx) +int __scf_async(uintptr_t funcptr, const char* fmt, uintptr_t rdx, uintptr_t rcx, uintptr_t r8, uintptr_t r9, uintptr_t* rsp, + double xmm0, double xmm1, double xmm2, double xmm3, double xmm4, double xmm5, double xmm6, double xmm7) { - if (!co_thread) { - if (scf_co_thread_open(&co_thread) < 0) { + if (!__co_thread) { + if (scf_co_thread_open(&__co_thread) < 0) { scf_loge("\n"); return -1; } @@ -129,12 +205,14 @@ int scf_async(uintptr_t funcptr, uintptr_t rdi, uintptr_t rsi, uintptr_t rdx) scf_co_task_t* task = NULL; - if (scf_co_task_alloc(&task, funcptr, rdi, rsi, rdx, 0) < 0) { + int ret = scf_co_task_alloc(&task, funcptr, fmt, rdx, rcx, r8, r9, rsp, + xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7); + if (ret < 0) { scf_loge("\n"); - return -1; + return ret; } - scf_co_thread_add_task(co_thread, task); + scf_co_thread_add_task(__co_thread, task); return 0; } @@ -142,7 +220,7 @@ int __save_stack(scf_co_task_t* task) { task->stack_len = task->rsp0 - task->rsp; - scf_loge("task: %p, stack_len: %ld, start: %#lx, end: %#lx, task->rip: %#lx\n", + scf_logi("task: %p, stack_len: %ld, start: %#lx, end: %#lx, task->rip: %#lx\n", task, task->stack_len, task->rsp, task->rsp0, task->rip); if (task->stack_len > task->stack_capacity) { @@ -162,7 +240,7 @@ int __save_stack(scf_co_task_t* task) void __async_msleep(int64_t msec) { - scf_co_thread_t* thread = co_thread; + scf_co_thread_t* thread = __co_thread; scf_co_task_t* task = thread->current; if (task->time > 0) @@ -256,8 +334,8 @@ static int _co_read_to_bufs(scf_co_task_t* task) static int _co_add_event(int fd, uint32_t events) { - scf_co_thread_t* thread = co_thread; - scf_co_task_t* task = thread->current; + scf_co_thread_t* thread = __co_thread; + scf_co_task_t* task = thread->current; struct epoll_event ev; ev.events = events | EPOLLET | EPOLLRDHUP; @@ -283,8 +361,8 @@ static int _co_add_event(int fd, uint32_t events) int __async_connect(int fd, const struct sockaddr *addr, socklen_t addrlen, int64_t msec) { - scf_co_thread_t* thread = co_thread; - scf_co_task_t* task = thread->current; + scf_co_thread_t* thread = __co_thread; + scf_co_task_t* task = thread->current; int flags = fcntl(fd, F_GETFL); flags |= O_NONBLOCK; @@ -335,7 +413,7 @@ int __async_connect(int fd, const struct sockaddr *addr, socklen_t addrlen, int6 err = -err; } - scf_loge("err: %d\n", err); + scf_logi("err: %d\n", err); } if (epoll_ctl(thread->epfd, EPOLL_CTL_DEL, fd, NULL) < 0) { @@ -344,7 +422,6 @@ int __async_connect(int fd, const struct sockaddr *addr, socklen_t addrlen, int6 } if (task->time > 0) { - scf_loge("\n"); scf_rbtree_delete(&thread->timers, &task->timer); task->time = 0; } @@ -354,8 +431,8 @@ int __async_connect(int fd, const struct sockaddr *addr, socklen_t addrlen, int6 int __async_read(int fd, void* buf, size_t count, int64_t msec) { - scf_co_thread_t* thread = co_thread; - scf_co_task_t* task = thread->current; + scf_co_thread_t* thread = __co_thread; + scf_co_task_t* task = thread->current; int ret = _co_add_event(fd, EPOLLIN); if (ret < 0) { @@ -402,8 +479,8 @@ int __async_read(int fd, void* buf, size_t count, int64_t msec) int __async_write(int fd, void* buf, size_t count) { - scf_co_thread_t* thread = co_thread; - scf_co_task_t* task = thread->current; + scf_co_thread_t* thread = __co_thread; + scf_co_task_t* task = thread->current; int ret = _co_add_event(fd, EPOLLOUT); if (ret < 0) { @@ -438,13 +515,13 @@ int __async_write(int fd, void* buf, size_t count) void __async_exit() { - if (co_thread) - co_thread->exit_flag = 1; + if (__co_thread) + __co_thread->exit_flag = 1; } int __async_loop() { - return scf_co_thread_run(co_thread); + return scf_co_thread_run(__co_thread); } #define SCF_CO_TASK_DELETE(task) \ @@ -455,7 +532,7 @@ int __async_loop() } \ \ scf_list_del(&task->list); \ - thread->nb_tasks--; \ + thread->n_tasks--; \ \ scf_co_task_free(task); \ task = NULL; \ @@ -466,18 +543,32 @@ int scf_co_thread_run(scf_co_thread_t* thread) if (!thread) return -EINVAL; + int n_tasks = thread->n_tasks + 1; + + struct epoll_event* events = malloc(n_tasks * sizeof(struct epoll_event)); + if (!events) + return -ENOMEM; + while (!thread->exit_flag) { - assert(thread->nb_tasks >= 0); + assert(thread->n_tasks >= 0); - if (0 == thread->nb_tasks) + if (0 == thread->n_tasks) break; - struct epoll_event* events = calloc(thread->nb_tasks + 1, sizeof(struct epoll_event)); - if (!events) - return -ENOMEM; + if (n_tasks < thread->n_tasks + 1) { + n_tasks = thread->n_tasks + 1; + + void* p = realloc(events, n_tasks * sizeof(struct epoll_event)); + if (!p) { + free(events); + return -ENOMEM; + } + + events = p; + } - int ret = epoll_wait(thread->epfd, events, thread->nb_tasks + 1, 300); + int ret = epoll_wait(thread->epfd, events, n_tasks, 10); if (ret < 0) { scf_loge("errno: %d\n", errno); @@ -495,42 +586,47 @@ int scf_co_thread_run(scf_co_thread_t* thread) int ret2 = __scf_co_task_run(task); - if (ret2 < 0 || SCF_CO_OK == ret2) { + if (ret2 < 0) { scf_loge("ret2: %d, thread: %p, task: %p\n", ret2, thread, task); + SCF_CO_TASK_DELETE(task); + + } else if (SCF_CO_OK == ret2) { + scf_logi("ret2: %d, thread: %p, task: %p\n", ret2, thread, task); + SCF_CO_TASK_DELETE(task); } } while (1) { scf_co_task_t* task = (scf_co_task_t*) scf_rbtree_min(&thread->timers, thread->timers.root); - if (!task) { - scf_loge("\n"); + if (!task) break; - } - if (task->time > scf_gettime()) { + if (task->time > scf_gettime()) break; - } scf_rbtree_delete(&thread->timers, &task->timer); task->time = 0; int ret2 = __scf_co_task_run(task); - if (ret2 < 0 || SCF_CO_OK == ret2) { + if (ret2 < 0) { scf_loge("ret2: %d, thread: %p, task: %p\n", ret2, thread, task); + SCF_CO_TASK_DELETE(task); + + } else if (SCF_CO_OK == ret2) { + scf_logi("ret2: %d, thread: %p, task: %p\n", ret2, thread, task); + SCF_CO_TASK_DELETE(task); } } - free(events); - events = NULL; } - scf_loge("async exit\n"); + scf_logi("async exit\n"); + free(events); return 0; } - diff --git a/coroutine/scf_coroutine.h b/coroutine/scf_coroutine.h index 6d25b0a..abfc4c5 100644 --- a/coroutine/scf_coroutine.h +++ b/coroutine/scf_coroutine.h @@ -18,6 +18,8 @@ typedef struct scf_co_thread_s scf_co_thread_t; typedef struct scf_co_buf_s scf_co_buf_t; +extern scf_co_thread_t* __co_thread; + struct scf_co_buf_s { scf_co_buf_t* next; @@ -48,6 +50,7 @@ struct scf_co_task_s intptr_t stack_len; intptr_t stack_capacity; + int n_floats; int err; uint32_t events; @@ -63,7 +66,7 @@ struct scf_co_thread_s scf_rbtree_t timers; scf_list_t tasks; - int nb_tasks; + int n_tasks; scf_co_task_t* current; @@ -78,17 +81,19 @@ int __async_connect(int fd, const struct sockaddr *addr, socklen_t addrlen, int int __async_loop(); -int scf_co_thread_open (scf_co_thread_t** pthread); -int scf_co_thread_close(scf_co_thread_t* thread); +int scf_co_thread_open (scf_co_thread_t** pthread); +int scf_co_thread_close(scf_co_thread_t* thread); + +void scf_co_thread_add_task(scf_co_thread_t* thread, scf_co_task_t* task); -int scf_co_thread_add_task(scf_co_thread_t* thread, scf_co_task_t* task); +int scf_co_thread_run(scf_co_thread_t* thread); -int scf_co_thread_run(scf_co_thread_t* thread); +int scf_co_task_alloc(scf_co_task_t** ptask, uintptr_t funcptr, const char* fmt, uintptr_t rdx, uintptr_t rcx, uintptr_t r8, uintptr_t r9, uintptr_t* rsp, + double xmm0, double xmm1, double xmm2, double xmm3, double xmm4, double xmm5, double xmm6, double xmm7); -int scf_co_task_alloc(scf_co_task_t** ptask, uintptr_t func_ptr, uintptr_t rdi, uintptr_t rsi, uintptr_t rdx, uintptr_t rcx); void scf_co_task_free(scf_co_task_t* task); -int scf_async(uintptr_t funcptr, uintptr_t rdi, uintptr_t rsi, uintptr_t rdx); +int __scf_async(uintptr_t funcptr, const char* fmt, uintptr_t rdx, uintptr_t rcx, uintptr_t r8, uintptr_t r9, uintptr_t* rsp, + double xmm0, double xmm1, double xmm2, double xmm3, double xmm4, double xmm5, double xmm6, double xmm7); #endif - diff --git a/coroutine/scf_coroutine_asm.S b/coroutine/scf_coroutine_asm.S index fb579b6..a419427 100644 --- a/coroutine/scf_coroutine_asm.S +++ b/coroutine/scf_coroutine_asm.S @@ -1,6 +1,6 @@ .text -.global __asm_co_task_run, __asm_co_task_yield, __asm_co_task_resume -.global __jmp_ret, __jmp_yield +.global __asm_co_task_run, __asm_co_task_yield, __save_stack +.global scf_async, __scf_async .align 8 __asm_co_task_run: @@ -9,6 +9,7 @@ __asm_co_task_run: # rdx, task_rip # rcx, stack_len # r8, task_rsp0 addr +# r9, n_floats push %rbp push %rdi @@ -25,29 +26,64 @@ __asm_co_task_run: mov (%r8), %rax mov %rsp, (%r8) - mov %rdx, %r8 + mov %rdx, %rbx mov %rsp, %rbp _fill: sub %rcx, %rsp mov %rsp, %rdi + + push %rcx + test $0x7, %rcx + jne 1f + + shr $3, %rcx + cld + rep movsq + jmp 3f +1: + test $0x3, %rcx + jne 2f + + shr $2, %rcx + cld + rep movsl + jmp 3f +2: cld rep movsb +3: + pop %rcx test %rax, %rax jne _jmp + movq %r9, %rax + pop %rdi pop %rsi pop %rdx pop %rcx + pop %r8 + pop %r9 + + movsd (%rsp), %xmm0 + movsd 8(%rsp), %xmm1 + movsd 16(%rsp), %xmm2 + movsd 24(%rsp), %xmm3 + movsd 32(%rsp), %xmm4 + movsd 40(%rsp), %xmm5 + movsd 48(%rsp), %xmm6 + movsd 56(%rsp), %xmm7 - call *%r8 + addq $64, %rsp + + call *%rbx jmp _reset _jmp: - jmp *%r8 + jmp *%rbx _reset: mov %rbp, %rsp @@ -88,13 +124,16 @@ __asm_co_task_yield: push %r14 push %r15 - movq $__jmp_yield, (%rsi) + jmp 2f +1: + pop %rax # rax == __jmp_yield + movq %rax, (%rsi) mov %rsp, (%rdx) push %rsp push %rcx - call __save_stack + call __save_stack@PLT pop %rcx pop %rsp @@ -103,6 +142,8 @@ __asm_co_task_yield: jmp __jmp_ret +2: + call 1b __jmp_yield: pop %r15 pop %r14 @@ -120,3 +161,26 @@ __jmp_yield: mov %rsp, %rax ret +.align 8 +scf_async: +# rdi, funcptr +# rsi, fmt +# rdx, d0 +# rcx, d1 +# r8, d2 +# r9, d3 +# xmm0-xmm7, f0-f7 + +# 24(rsp), ... +# 16(rsp), stack arg1 +# 8(rsp), stack arg0 <--- rax +# 0(rsp), ret addr + + movq %rsp, %rax + addq $8, %rax + + push %rax + call __scf_async@PLT + + addq $8, %rsp + ret diff --git a/coroutine/scf_coroutine_run.c b/coroutine/scf_coroutine_run.c index a22b50e..f2a181e 100644 --- a/coroutine/scf_coroutine_run.c +++ b/coroutine/scf_coroutine_run.c @@ -1,7 +1,7 @@ #include"scf_coroutine.h" uintptr_t __asm_co_task_run(uintptr_t* task_rsp, void* stack_data, - uintptr_t task_rip, intptr_t stack_len, uintptr_t* task_rsp0); + uintptr_t task_rip, intptr_t stack_len, uintptr_t* task_rsp0, int n_floats); int __scf_co_task_run(scf_co_task_t* task) { @@ -10,22 +10,19 @@ int __scf_co_task_run(scf_co_task_t* task) task->err = 0; uintptr_t rsp1 = 0; - scf_loge("task %p, rsp0: %#lx, rsp1: %#lx\n", task, task->rsp0, rsp1); + scf_logw("task %p, rsp0: %#lx, rsp1: %#lx\n", task, task->rsp0, rsp1); rsp1 = __asm_co_task_run(&task->rsp, task->stack_data, task->rip, - task->stack_len, &task->rsp0); + task->stack_len, &task->rsp0, task->n_floats); if (task->err) { scf_loge("task %p error: %d, rsp0: %#lx, rsp1: %#lx, task->time: %ld\n", task, task->err, task->rsp0, rsp1, task->time); return task->err; - } else if (task->rsp0 == rsp1) { -// scf_loge("task %p run ok, rsp0: %#lx, rsp1: %#lx, task->time: %ld\n", task, task->rsp0, rsp1, task->time); + } else if (task->rsp0 == rsp1) return SCF_CO_OK; - } - scf_loge("task %p running, rsp0: %#lx, rsp1: %#lx\n", task, task->rsp0, rsp1); + scf_logi("task %p running, rsp0: %#lx, rsp1: %#lx\n", task, task->rsp0, rsp1); return SCF_CO_CONTINUE; } - diff --git a/elf/scf_elf_arm32.c b/elf/scf_elf_arm32.c index dcbae44..1c1b260 100644 --- a/elf/scf_elf_arm32.c +++ b/elf/scf_elf_arm32.c @@ -21,14 +21,14 @@ static int _arm32_elf_link_cs(elf_native_t* arm32, elf_section_t* s, elf_section int sym_idx = ELF32_R_SYM(rela->r_info); - scf_loge("i: %d, sym_idx '%d'\n", i, sym_idx); + scf_logd("i: %d, sym_idx '%d'\n", i, sym_idx); assert(sym_idx >= 1); assert(sym_idx - 1 < arm32->symbols->size); sym = arm32->symbols->data[sym_idx - 1]; if (sym->dyn_flag) { - scf_loge("sym '%s' in dynamic so\n", sym->name->data); + scf_logd("sym '%s' in dynamic so\n", sym->name->data); continue; } @@ -47,7 +47,7 @@ static int _arm32_elf_link_cs(elf_native_t* arm32, elf_section_t* s, elf_section offset -= 8; // 'pc' is 'current + 8'. assert(0 == (offset & 0x3)); - scf_loge("sym: %s, offset: %#x, %#x\n", sym->name->data, offset, rela->r_offset); + scf_logd("sym: %s, offset: %#x, %#x\n", sym->name->data, offset, rela->r_offset); offset >>= 2; if (offset > 0x7fffff || offset < -0x7fffff) { @@ -55,20 +55,20 @@ static int _arm32_elf_link_cs(elf_native_t* arm32, elf_section_t* s, elf_section return -EINVAL; } - scf_loge("sym: %s, offset: %#x, %#x\n", sym->name->data, offset, rela->r_offset); + scf_logd("sym: %s, offset: %#x, %#x\n", sym->name->data, offset, rela->r_offset); *(uint32_t*)(s->data + rela->r_offset) &= 0xff000000; *(uint32_t*)(s->data + rela->r_offset) |= 0x00ffffff & offset; break; case R_ARM_REL32: - scf_loge("sym: %s, offset: %#x, %#x, st_value: %#x, cs: %#lx\n", sym->name->data, offset, rela->r_offset, + scf_logd("sym: %s, offset: %#x, %#x, st_value: %#x, cs: %#lx\n", sym->name->data, offset, rela->r_offset, sym->sym.st_value, cs_base + rela->r_offset); *(uint32_t*)(s->data + rela->r_offset) += offset; break; default: - scf_loge("ELF32_R_TYPE(rela->r_info): %d\n", ELF32_R_TYPE(rela->r_info)); + scf_logd("ELF32_R_TYPE(rela->r_info): %d\n", ELF32_R_TYPE(rela->r_info)); return -EINVAL; break; }; @@ -194,7 +194,7 @@ static int _arm32_elf_link_sections(elf_native_t* arm32, uint32_t cs_index, uint s = arm32->sections->data[rs->sh.sh_info - 1]; - scf_loge("s: %s, rs: %s, rs->sh.sh_info: %u\n", s->name->data, rs->name->data, rs->sh.sh_info); + scf_logd("s: %s, rs: %s, rs->sh.sh_info: %u\n", s->name->data, rs->name->data, rs->sh.sh_info); assert(!strcmp(s->name->data, rs->name->data + 5)); @@ -236,7 +236,7 @@ static int _arm32_elf_write_exec(scf_elf_context_t* elf, const char* sysroot) for (i = 0; i < arm32->sections->size; i++) { s = arm32->sections->data[i]; - scf_logw("i: %d, section: %s\n", i, s->name->data); + scf_logd("i: %d, section: %s\n", i, s->name->data); if (!strcmp(".text", s->name->data)) { @@ -260,7 +260,7 @@ static int _arm32_elf_write_exec(scf_elf_context_t* elf, const char* sysroot) assert(!crela); crela = s; - scf_loge("i: %d, section: %s\n", i, s->name->data); + scf_logd("i: %d, section: %s\n", i, s->name->data); } else if (!strcmp(".rela.data", s->name->data)) { diff --git a/elf/scf_elf_arm32_so.c b/elf/scf_elf_arm32_so.c index 3a3dbd1..5049122 100644 --- a/elf/scf_elf_arm32_so.c +++ b/elf/scf_elf_arm32_so.c @@ -256,9 +256,9 @@ static int _arm32_elf_add_dynamic(elf_native_t* arm32, elf_section_t** ps) } s->data_len = nb_tags * sizeof(Elf32_Dyn); - scf_logw("nb_tags: %d\n", nb_tags); + scf_logd("nb_tags: %d\n", nb_tags); - s->index = 1; + s->index = 1; s->sh.sh_type = SHT_PROGBITS; s->sh.sh_flags = SHF_ALLOC | SHF_WRITE; @@ -464,7 +464,7 @@ int __arm32_elf_add_dyn (elf_native_t* arm32, const char* sysroot) s->index = arm32->sections->size + 1 + sizeof(sh_names) / sizeof(sh_names[0]); - scf_logw("s: %s, link: %d, info: %d\n", s->name->data, s->sh.sh_link, s->sh.sh_info); + scf_logd("s: %s, link: %d, info: %d\n", s->name->data, s->sh.sh_link, s->sh.sh_info); if (s->sh.sh_link > 0) { assert(s->sh.sh_link - 1 < arm32->sections->size); @@ -509,7 +509,7 @@ int __arm32_elf_add_dyn (elf_native_t* arm32, const char* sysroot) syms[i + 1].st_name = str->len; - scf_loge("i: %d, st_value: %#x\n", i, syms[i + 1].st_value); + scf_logd("i: %d, st_value: %#x\n", i, syms[i + 1].st_value); scf_string_cat_cstr_len(str, xsym->name->data, xsym->name->len + 1); } @@ -550,7 +550,7 @@ int __arm32_elf_add_dyn (elf_native_t* arm32, const char* sysroot) dyns[i].d_tag = DT_NEEDED; dyns[i].d_un.d_val = str->len; - scf_logw("i: %d, %s, %s\n", i, needed->data, needed->data + prefix); + scf_logi("i: %d, %s, %s\n", i, needed->data, needed->data + prefix); scf_string_cat_cstr_len(str, needed->data + prefix, needed->len - prefix + 1); } @@ -631,7 +631,7 @@ int __arm32_elf_add_dyn (elf_native_t* arm32, const char* sysroot) for (i = 0; i < arm32->sections->size; i++) { s = arm32->sections->data[i]; - scf_loge("i: %d, s: %s, index: %d\n", i, s->name->data, s->index); + scf_logd("i: %d, s: %s, index: %d\n", i, s->name->data, s->index); if (s->link) { scf_logd("link: %s, index: %d\n", s->link->name->data, s->link->index); @@ -660,7 +660,7 @@ int __arm32_elf_add_dyn (elf_native_t* arm32, const char* sysroot) sym = arm32->symbols->data[i]; if (sym->section) { - scf_logw("sym: %s, index: %d->%d\n", sym->name->data, sym->sym.st_shndx, sym->section->index); + scf_logd("sym: %s, index: %d->%d\n", sym->name->data, sym->sym.st_shndx, sym->section->index); sym->sym.st_shndx = sym->section->index; } } @@ -680,8 +680,8 @@ int __arm32_elf_post_dyn(elf_native_t* arm32, uint64_t rx_base, uint64_t rw_base arm32->interp->sh.sh_addr = rx_base + arm32->interp->offset; arm32->plt->sh.sh_addr = rx_base + arm32->plt->offset; - scf_loge("rw_base: %#lx, offset: %#lx\n", rw_base, arm32->got_plt->offset); - scf_loge("got_addr: %#x\n", arm32->got_plt->sh.sh_addr); + scf_logi("rw_base: %#lx, offset: %#lx\n", rw_base, arm32->got_plt->offset); + scf_logi("got_addr: %#x\n", arm32->got_plt->sh.sh_addr); Elf32_Rela* r; Elf32_Rela* rela_plt = (Elf32_Rela*)arm32->rela_plt->data; @@ -701,7 +701,7 @@ int __arm32_elf_post_dyn(elf_native_t* arm32, uint64_t rx_base, uint64_t rw_base got_plt += 4; got_addr +=16; - scf_loge("got_addr: %#lx, plt_addr: %#lx, offset: %d, %#x\n", got_addr, plt_addr, offset, offset); + scf_logi("got_addr: %#lx, plt_addr: %#lx, offset: %d, %#x\n", got_addr, plt_addr, offset, offset); plt[4] = offset - 16; @@ -718,9 +718,9 @@ int __arm32_elf_post_dyn(elf_native_t* arm32, uint64_t rx_base, uint64_t rw_base offset = got_addr - plt_addr - 8; // 'pc = current + 8' - scf_loge("i: %d, got_addr: %#lx, plt_addr: %#lx, offset: %d, %#x\n", i, got_addr, plt_addr, offset, offset); + scf_logd("i: %d, got_addr: %#lx, plt_addr: %#lx, offset: %d, %#x\n", i, got_addr, plt_addr, offset, offset); - scf_logw("got_plt[%d]: %#x\n", i, *got_plt); + scf_logd("got_plt[%d]: %#x\n", i, *got_plt); if (offset > 0xfffffff) { scf_loge("\n"); diff --git a/elf/scf_elf_arm64.c b/elf/scf_elf_arm64.c index 07a5901..55bcedb 100644 --- a/elf/scf_elf_arm64.c +++ b/elf/scf_elf_arm64.c @@ -53,7 +53,7 @@ static int _arm64_elf_link_cs(elf_native_t* arm64, elf_section_t* s, elf_section offset &= 0x3ffffff; - scf_loge("sym: %s, offset: %#x, %#lx\n", sym->name->data, offset, rela->r_offset); + scf_logd("sym: %s, offset: %#x, %#lx\n", sym->name->data, offset, rela->r_offset); *(uint32_t*)(s->data + rela->r_offset) |= offset; break; @@ -207,7 +207,7 @@ static int _arm64_elf_link_sections(elf_native_t* arm64, uint32_t cs_index, uint s = arm64->sections->data[rs->sh.sh_info - 1]; - scf_loge("s: %s, rs: %s, rs->sh.sh_info: %u\n", s->name->data, rs->name->data, rs->sh.sh_info); + scf_logd("s: %s, rs: %s, rs->sh.sh_info: %u\n", s->name->data, rs->name->data, rs->sh.sh_info); assert(!strcmp(s->name->data, rs->name->data + 5)); diff --git a/elf/scf_elf_arm64_so.c b/elf/scf_elf_arm64_so.c index 0f4a0f2..60d8883 100644 --- a/elf/scf_elf_arm64_so.c +++ b/elf/scf_elf_arm64_so.c @@ -466,7 +466,7 @@ int __arm64_elf_add_dyn(elf_native_t* arm64, const char* sysroot) s->index = arm64->sections->size + 1 + sizeof(sh_names) / sizeof(sh_names[0]); - scf_logw("s: %s, link: %d, info: %d\n", s->name->data, s->sh.sh_link, s->sh.sh_info); + scf_logd("s: %s, link: %d, info: %d\n", s->name->data, s->sh.sh_link, s->sh.sh_info); if (s->sh.sh_link > 0) { assert(s->sh.sh_link - 1 < arm64->sections->size); @@ -511,7 +511,7 @@ int __arm64_elf_add_dyn(elf_native_t* arm64, const char* sysroot) syms[i + 1].st_name = str->len; - scf_loge("i: %d, st_value: %#lx\n", i, syms[i + 1].st_value); + scf_logi("i: %d, st_value: %#lx\n", i, syms[i + 1].st_value); scf_string_cat_cstr_len(str, xsym->name->data, xsym->name->len + 1); } @@ -552,7 +552,7 @@ int __arm64_elf_add_dyn(elf_native_t* arm64, const char* sysroot) dyns[i].d_tag = DT_NEEDED; dyns[i].d_un.d_val = str->len; - scf_logw("i: %d, %s, %s\n", i, needed->data, needed->data + prefix); + scf_logd("i: %d, %s, %s\n", i, needed->data, needed->data + prefix); scf_string_cat_cstr_len(str, needed->data + prefix, needed->len - prefix + 1); } @@ -632,7 +632,7 @@ int __arm64_elf_add_dyn(elf_native_t* arm64, const char* sysroot) for (i = 0; i < arm64->sections->size; i++) { s = arm64->sections->data[i]; - scf_loge("i: %d, s: %s, index: %d\n", i, s->name->data, s->index); + scf_logd("i: %d, s: %s, index: %d\n", i, s->name->data, s->index); if (s->link) { scf_logd("link: %s, index: %d\n", s->link->name->data, s->link->index); @@ -650,7 +650,7 @@ int __arm64_elf_add_dyn(elf_native_t* arm64, const char* sysroot) sym = arm64->symbols->data[i]; if (sym->section) { - scf_logw("sym: %s, index: %d->%d\n", sym->name->data, sym->sym.st_shndx, sym->section->index); + scf_logd("sym: %s, index: %d->%d\n", sym->name->data, sym->sym.st_shndx, sym->section->index); sym->sym.st_shndx = sym->section->index; } } @@ -670,8 +670,8 @@ int __arm64_elf_post_dyn(elf_native_t* arm64, uint64_t rx_base, uint64_t rw_base arm64->interp->sh.sh_addr = rx_base + arm64->interp->offset; arm64->plt->sh.sh_addr = rx_base + arm64->plt->offset; - scf_loge("rw_base: %#lx, offset: %#lx\n", rw_base, arm64->got_plt->offset); - scf_loge("got_addr: %#lx\n", arm64->got_plt->sh.sh_addr); + scf_logi("rw_base: %#lx, offset: %#lx\n", rw_base, arm64->got_plt->offset); + scf_logi("got_addr: %#lx\n", arm64->got_plt->sh.sh_addr); Elf64_Rela* rela_plt = (Elf64_Rela*)arm64->rela_plt->data; Elf64_Sym* dynsym = (Elf64_Sym* )arm64->dynsym->data; @@ -690,7 +690,7 @@ int __arm64_elf_post_dyn(elf_native_t* arm64, uint64_t rx_base, uint64_t rw_base got_plt += 3; got_addr += 8; - scf_loge("got_addr: %#lx, plt_addr: %#lx, offset: %d, %#x\n", got_addr, plt_addr, offset, offset); + scf_logi("got_addr: %#lx, plt_addr: %#lx, offset: %d, %#x\n", got_addr, plt_addr, offset, offset); plt[1] |= (((offset >> 12) & 0x3) << 29) | (((offset >> 14) & 0x7ffff) << 5); plt[2] |= ((got_addr & 0xfff) >> 3) << 10; @@ -710,7 +710,7 @@ int __arm64_elf_post_dyn(elf_native_t* arm64, uint64_t rx_base, uint64_t rw_base offset = got_addr - plt_addr; - scf_loge("i: %d, got_addr: %#lx, plt_addr: %#lx, offset: %d, %#x\n", i, got_addr, plt_addr, offset, offset); + scf_logi("i: %d, got_addr: %#lx, plt_addr: %#lx, offset: %d, %#x\n", i, got_addr, plt_addr, offset, offset); plt[0] |= (((offset >> 12) & 0x3) << 29) | (((offset >> 14) & 0x7ffff) << 5); plt[1] |= ((got_addr & 0xfff) >> 3) << 10; diff --git a/elf/scf_elf_naja.c b/elf/scf_elf_naja.c index dd20336..c911a65 100644 --- a/elf/scf_elf_naja.c +++ b/elf/scf_elf_naja.c @@ -53,7 +53,7 @@ static int _naja_elf_link_cs(elf_native_t* naja, elf_section_t* s, elf_section_t offset &= 0x3ffffff; - scf_loge("sym: %s, offset: %#x, %#lx\n", sym->name->data, offset, rela->r_offset); + scf_logi("sym: %s, offset: %#x, %#lx\n", sym->name->data, offset, rela->r_offset); *(uint32_t*)(s->data + rela->r_offset) |= offset; break; @@ -207,7 +207,7 @@ static int _naja_elf_link_sections(elf_native_t* naja, uint32_t cs_index, uint32 s = naja->sections->data[rs->sh.sh_info - 1]; - scf_loge("s: %s, rs: %s, rs->sh.sh_info: %u\n", s->name->data, rs->name->data, rs->sh.sh_info); + scf_logi("s: %s, rs: %s, rs->sh.sh_info: %u\n", s->name->data, rs->name->data, rs->sh.sh_info); assert(!strcmp(s->name->data, rs->name->data + 5)); diff --git a/elf/scf_elf_naja_so.c b/elf/scf_elf_naja_so.c index 31690c5..486dbb7 100644 --- a/elf/scf_elf_naja_so.c +++ b/elf/scf_elf_naja_so.c @@ -467,7 +467,7 @@ int __naja_elf_add_dyn(elf_native_t* naja, const char* sysroot) s->index = naja->sections->size + 1 + sizeof(sh_names) / sizeof(sh_names[0]); - scf_logw("s: %s, link: %d, info: %d\n", s->name->data, s->sh.sh_link, s->sh.sh_info); + scf_logd("s: %s, link: %d, info: %d\n", s->name->data, s->sh.sh_link, s->sh.sh_info); if (s->sh.sh_link > 0) { assert(s->sh.sh_link - 1 < naja->sections->size); @@ -512,7 +512,7 @@ int __naja_elf_add_dyn(elf_native_t* naja, const char* sysroot) syms[i + 1].st_name = str->len; - scf_loge("i: %d, st_value: %#lx\n", i, syms[i + 1].st_value); + scf_logi("i: %d, st_value: %#lx\n", i, syms[i + 1].st_value); scf_string_cat_cstr_len(str, xsym->name->data, xsym->name->len + 1); } @@ -553,7 +553,7 @@ int __naja_elf_add_dyn(elf_native_t* naja, const char* sysroot) dyns[i].d_tag = DT_NEEDED; dyns[i].d_un.d_val = str->len; - scf_logw("i: %d, %s, %s\n", i, needed->data, needed->data + prefix); + scf_logd("i: %d, %s, %s\n", i, needed->data, needed->data + prefix); scf_string_cat_cstr_len(str, needed->data + prefix, needed->len - prefix + 1); } @@ -633,7 +633,7 @@ int __naja_elf_add_dyn(elf_native_t* naja, const char* sysroot) for (i = 0; i < naja->sections->size; i++) { s = naja->sections->data[i]; - scf_loge("i: %d, s: %s, index: %d\n", i, s->name->data, s->index); + scf_logd("i: %d, s: %s, index: %d\n", i, s->name->data, s->index); if (s->link) { scf_logd("link: %s, index: %d\n", s->link->name->data, s->link->index); @@ -651,7 +651,7 @@ int __naja_elf_add_dyn(elf_native_t* naja, const char* sysroot) sym = naja->symbols->data[i]; if (sym->section) { - scf_logw("sym: %s, index: %d->%d\n", sym->name->data, sym->sym.st_shndx, sym->section->index); + scf_logd("sym: %s, index: %d->%d\n", sym->name->data, sym->sym.st_shndx, sym->section->index); sym->sym.st_shndx = sym->section->index; } } @@ -671,8 +671,8 @@ int __naja_elf_post_dyn(elf_native_t* naja, uint64_t rx_base, uint64_t rw_base, naja->interp->sh.sh_addr = rx_base + naja->interp->offset; naja->plt->sh.sh_addr = rx_base + naja->plt->offset; - scf_loge("rw_base: %#lx, offset: %#lx\n", rw_base, naja->got_plt->offset); - scf_loge("got_addr: %#lx\n", naja->got_plt->sh.sh_addr); + scf_logi("rw_base: %#lx, offset: %#lx\n", rw_base, naja->got_plt->offset); + scf_logi("got_addr: %#lx\n", naja->got_plt->sh.sh_addr); Elf64_Rela* rela_plt = (Elf64_Rela*)naja->rela_plt->data; Elf64_Sym* dynsym = (Elf64_Sym* )naja->dynsym->data; @@ -691,7 +691,7 @@ int __naja_elf_post_dyn(elf_native_t* naja, uint64_t rx_base, uint64_t rw_base, got_plt += 3; got_addr += 8; - scf_loge("got_addr: %#lx, plt_addr: %#lx, offset: %d, %#x\n", got_addr, plt_addr, offset, offset); + scf_logi("got_addr: %#lx, plt_addr: %#lx, offset: %d, %#x\n", got_addr, plt_addr, offset, offset); plt[2] |= (offset >> 15) & 0x1fffff; plt[3] |= (got_addr & 0x7fff) << 5; @@ -710,7 +710,7 @@ int __naja_elf_post_dyn(elf_native_t* naja, uint64_t rx_base, uint64_t rw_base, offset = got_addr - plt_addr; - scf_loge("i: %d, got_addr: %#lx, plt_addr: %#lx, offset: %d, %#x\n", i, got_addr, plt_addr, offset, offset); + scf_logi("i: %d, got_addr: %#lx, plt_addr: %#lx, offset: %d, %#x\n", i, got_addr, plt_addr, offset, offset); plt[0] |= (offset >> 15) & 0x1fffff; plt[1] |= (got_addr & 0x7fff) << 5; diff --git a/elf/scf_elf_native32.c b/elf/scf_elf_native32.c index 70384a8..deef2cb 100644 --- a/elf/scf_elf_native32.c +++ b/elf/scf_elf_native32.c @@ -555,7 +555,7 @@ int elf32_read_syms(scf_elf_context_t* elf, scf_vector_t* syms, const char* sh_n assert(symtab->data_len % sizeof(Elf32_Sym) == 0); - scf_loge("0: syms->size: %d, %ld\n", syms->size, symtab->data_len / sizeof(Elf32_Sym)); + scf_logd("0: syms->size: %d, %ld\n", syms->size, symtab->data_len / sizeof(Elf32_Sym)); scf_elf_sym_t* esym; Elf32_Sym* sym; @@ -588,7 +588,7 @@ int elf32_read_syms(scf_elf_context_t* elf, scf_vector_t* syms, const char* sh_n } } - scf_loge("1: j: %d, syms->size: %d, %ld\n", j, syms->size, symtab->data_len / sizeof(Elf32_Sym)); + scf_logd("1: j: %d, syms->size: %d, %ld\n", j, syms->size, symtab->data_len / sizeof(Elf32_Sym)); return 0; } @@ -615,7 +615,7 @@ int elf32_add_dyn_need(scf_elf_context_t* elf, const char* soname) return -ENOMEM; } - scf_loge("soname: %s\n", soname); + scf_logi("soname: %s\n", soname); return 0; } @@ -671,7 +671,7 @@ int elf32_read_relas(scf_elf_context_t* elf, scf_vector_t* relas, const char* sh if (ret < 0) return ret; - scf_loge("sh_rela: %u\n", sh_rela->sh.sh_link); + scf_logd("sh_rela: %u\n", sh_rela->sh.sh_link); ret = __elf_read_section_by_index(elf, &symtab, sh_rela->sh.sh_link); if (ret < 0) { @@ -850,7 +850,7 @@ int elf32_write_sections(scf_elf_context_t* elf) for (i = 0; i < e->sections->size; i++) { s = e->sections->data[i]; - scf_loge("sh->name: %s, data: %p, len: %d\n", s->name->data, s->data, s->data_len); + scf_logd("sh->name: %s, data: %p, len: %d\n", s->name->data, s->data, s->data_len); if (s->data && s->data_len > 0) fwrite(s->data, s->data_len, 1, elf->fp); @@ -916,7 +916,7 @@ int elf32_write_rel(scf_elf_context_t* elf, uint16_t e_machine) local_syms++; } - scf_loge("e->symbols->size: %d\n", e->symbols->size); + scf_logd("e->symbols->size: %d\n", e->symbols->size); // .symtab header section_header(&e->sh_symtab, shstrtab, 0, offset, symtab, nb_sections - 2, local_syms, sizeof(Elf32_Sym)); diff --git a/elf/scf_elf_x64_so.c b/elf/scf_elf_x64_so.c index a764444..7c613ca 100644 --- a/elf/scf_elf_x64_so.c +++ b/elf/scf_elf_x64_so.c @@ -556,9 +556,12 @@ int __x64_elf_add_dyn(elf_native_t* x64, const char* sysroot) dyns[i].d_tag = DT_NEEDED; dyns[i].d_un.d_val = str->len; - scf_logd("i: %d, %s, %s\n", i, needed->data, needed->data + prefix); + scf_logi("i: %d, %s, %s\n", i, needed->data, needed->data + prefix); - scf_string_cat_cstr_len(str, needed->data + prefix, needed->len - prefix + 1); + if (!strncmp(needed->data, sysroot, strlen(sysroot))) + scf_string_cat_cstr_len(str, needed->data + prefix, needed->len - prefix + 1); + else + scf_string_cat_cstr_len(str, needed->data, needed->len + 1); } dyns[i].d_tag = DT_STRTAB; diff --git a/examples/coroutine_printf.c b/examples/coroutine_printf.c new file mode 100644 index 0000000..7da877e --- /dev/null +++ b/examples/coroutine_printf.c @@ -0,0 +1,15 @@ + +int printf(const char* fmt, ...); + +int scf_async(uintptr_t funcptr, const char* fmt, ...); + +int __async_loop(); + +int main() +{ + async printf("hello world, %d,%d,%d,%d, %lg,%lg,%lg,%lg, %lg,%lg,%lg,%lg, %lg-%lg\n", 1, 2, 3, 4, + 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.1); + + __async_loop(); + return 0; +} diff --git a/examples/init_array_reshape.c b/examples/init_array_reshape.c new file mode 100644 index 0000000..5770ab5 --- /dev/null +++ b/examples/init_array_reshape.c @@ -0,0 +1,25 @@ +int printf(const char* fmt, ...); + +int main() +{ + int a[2][2] = {1, 2, 3, 4}; + + int v = 3; + int i; + int j; + + for (i = 0; i < 2; i++) { + + for (j = 0; j < 2; j++) { + + if (v == a[i][j]) + break; + } + + if (j < 2) + break; + } + + printf("a[%d][%d] == v: %d\n", i, j, v); + return 0; +} diff --git a/native/risc/scf_risc.c b/native/risc/scf_risc.c index d3481a3..6d99f57 100644 --- a/native/risc/scf_risc.c +++ b/native/risc/scf_risc.c @@ -992,12 +992,12 @@ int _scf_risc_select_inst(scf_native_t* ctx) return ret; } - scf_loge("************ bb: %d, cmp_flag: %d\n", bb->index, bb->cmp_flag); + scf_logd("************ bb: %d, cmp_flag: %d\n", bb->index, bb->cmp_flag); ret = _risc_make_insts_for_list(ctx, bb, 0); if (ret < 0) return ret; bb->native_flag = 1; - scf_loge("************ bb: %d\n", bb->index); + scf_logd("************ bb: %d\n", bb->index); ret = risc_save_bb_colors(bb->dn_colors_exit, bbg, bb); if (ret < 0) diff --git a/native/risc/scf_risc_inst.c b/native/risc/scf_risc_inst.c index 6231fb1..1bf5a69 100644 --- a/native/risc/scf_risc_inst.c +++ b/native/risc/scf_risc_inst.c @@ -92,7 +92,7 @@ static int _risc_inst_call_argv(scf_native_t* ctx, scf_3ac_code_t* c, scf_functi } } - scf_loge("i: %d, size: %d, v: %s, rabi: %s\n", i, size, v->w->text->data, rabi->name); + scf_logd("i: %d, size: %d, v: %s, rabi: %s\n", i, size, v->w->text->data, rabi->name); movx = NULL; @@ -447,7 +447,7 @@ static int _risc_inst_call_handler(scf_native_t* ctx, scf_3ac_code_t* c) int data_rela_size = f->data_relas->size; int text_rela_size = f->text_relas->size; - scf_loge("f->data_relas->size: %d, f->text_relas->size: %d\n", f->data_relas->size, f->text_relas->size); + scf_logd("f->data_relas->size: %d, f->text_relas->size: %d\n", f->data_relas->size, f->text_relas->size); uint32_t opcode; int ret; @@ -494,7 +494,7 @@ static int _risc_inst_call_handler(scf_native_t* ctx, scf_3ac_code_t* c) return save_size; } - scf_loge("stack_size: %d, save_size: %d\n", stack_size, save_size); + scf_logd("stack_size: %d, save_size: %d\n", stack_size, save_size); if (stack_size > 0) { assert(inst_sp); @@ -1828,7 +1828,7 @@ static int _risc_inst_va_start_handler(scf_native_t* ctx, scf_3ac_code_t* c) return -ENOMEM; } - scf_loge("c->srcs->size: %d\n", c->srcs->size); + scf_logd("c->srcs->size: %d\n", c->srcs->size); assert(3 == c->srcs->size); scf_register_t* rbp = f->rops->find_register("rbp"); diff --git a/native/x64/scf_x64.c b/native/x64/scf_x64.c index 5ebd062..42cd47f 100644 --- a/native/x64/scf_x64.c +++ b/native/x64/scf_x64.c @@ -1091,7 +1091,7 @@ int _scf_x64_select_inst(scf_native_t* ctx) return ret; } } -#if 1 +#if 0 if (x64_optimize_peephole(ctx, f) < 0) { scf_loge("\n"); return -1; diff --git a/native/x64/scf_x64_reg.c b/native/x64/scf_x64_reg.c index 80548d1..3c998db 100644 --- a/native/x64/scf_x64_reg.c +++ b/native/x64/scf_x64_reg.c @@ -122,7 +122,7 @@ int x64_reg_cached_vars(scf_register_t* r) scf_register_t* r2 = &(x64_registers[i]); - if (SCF_X64_REG_RSP == r2->id || SCF_X64_REG_RBP == r2->id) + if (!X64_COLOR_TYPE(r2->color) && (SCF_X64_REG_RSP == r2->id || SCF_X64_REG_RBP == r2->id)) continue; if (!X64_COLOR_CONFLICT(r->color, r2->color)) @@ -141,7 +141,7 @@ int x64_registers_init() scf_register_t* r = &(x64_registers[i]); - if (SCF_X64_REG_RSP == r->id || SCF_X64_REG_RBP == r->id) + if (!X64_COLOR_TYPE(r->color) && (SCF_X64_REG_RSP == r->id || SCF_X64_REG_RBP == r->id)) continue; assert(!r->dag_nodes); @@ -163,7 +163,7 @@ void x64_registers_clear() scf_register_t* r = &(x64_registers[i]); - if (SCF_X64_REG_RSP == r->id || SCF_X64_REG_RBP == r->id) + if (!X64_COLOR_TYPE(r->color) && (SCF_X64_REG_RSP == r->id || SCF_X64_REG_RBP == r->id)) continue; if (r->dag_nodes) { @@ -187,7 +187,7 @@ void x64_registers_print() r = &(x64_registers[i]); - if (SCF_X64_REG_RSP == r->id || SCF_X64_REG_RBP == r->id) + if (!X64_COLOR_TYPE(r->color) && (SCF_X64_REG_RSP == r->id || SCF_X64_REG_RBP == r->id)) continue; if (!r->dag_nodes) @@ -231,7 +231,7 @@ int x64_caller_save_regs(scf_3ac_code_t* c, uint32_t* regs, int nb_regs, int sta for (i = 0; i < sizeof(x64_registers) / sizeof(x64_registers[0]); i++) { r = &(x64_registers[i]); - if (SCF_X64_REG_RSP == r->id || SCF_X64_REG_RBP == r->id) + if (!X64_COLOR_TYPE(r->color) && (SCF_X64_REG_RSP == r->id || SCF_X64_REG_RBP == r->id)) continue; if (0 == r->dag_nodes->size) @@ -312,7 +312,7 @@ int x64_push_regs(scf_vector_t* instructions, uint32_t* regs, int nb_regs) for (i = 0; i < sizeof(x64_registers) / sizeof(x64_registers[0]); i++) { r = &(x64_registers[i]); - if (SCF_X64_REG_RSP == r->id || SCF_X64_REG_RBP == r->id) + if (!X64_COLOR_TYPE(r->color) && (SCF_X64_REG_RSP == r->id || SCF_X64_REG_RBP == r->id)) continue; if (0 == r->dag_nodes->size) @@ -351,7 +351,7 @@ int x64_pop_regs(scf_vector_t* instructions, scf_register_t** regs, int nb_regs, for (i = 0; i < sizeof(x64_registers) / sizeof(x64_registers[0]); i++) { r = &(x64_registers[i]); - if (SCF_X64_REG_RSP == r->id || SCF_X64_REG_RBP == r->id) + if (!X64_COLOR_TYPE(r->color) && (SCF_X64_REG_RSP == r->id || SCF_X64_REG_RBP == r->id)) continue; if (0 == r->dag_nodes->size) @@ -390,7 +390,7 @@ int x64_registers_reset() scf_register_t* r = &(x64_registers[i]); - if (SCF_X64_REG_RSP == r->id || SCF_X64_REG_RBP == r->id) + if (!X64_COLOR_TYPE(r->color) && (SCF_X64_REG_RSP == r->id || SCF_X64_REG_RBP == r->id)) continue; if (!r->dag_nodes) @@ -482,7 +482,7 @@ scf_vector_t* x64_register_colors() scf_register_t* r = &(x64_registers[i]); - if (SCF_X64_REG_RSP == r->id || SCF_X64_REG_RBP == r->id) + if (!X64_COLOR_TYPE(r->color) && (SCF_X64_REG_RSP == r->id || SCF_X64_REG_RBP == r->id)) continue; // ah bh ch dh can't use @@ -620,7 +620,7 @@ int x64_overflow_reg(scf_register_t* r, scf_3ac_code_t* c, scf_function_t* f) scf_register_t* r2 = &(x64_registers[i]); - if (SCF_X64_REG_RSP == r2->id || SCF_X64_REG_RBP == r2->id) + if (!X64_COLOR_TYPE(r2->color) && (SCF_X64_REG_RSP == r2->id || SCF_X64_REG_RBP == r2->id)) continue; if (!X64_COLOR_CONFLICT(r->color, r2->color)) @@ -649,7 +649,7 @@ int x64_overflow_reg2(scf_register_t* r, scf_dag_node_t* dn, scf_3ac_code_t* c, r2 = &(x64_registers[i]); - if (SCF_X64_REG_RSP == r2->id || SCF_X64_REG_RBP == r2->id) + if (!X64_COLOR_TYPE(r2->color) && (SCF_X64_REG_RSP == r2->id || SCF_X64_REG_RBP == r2->id)) continue; if (!X64_COLOR_CONFLICT(r->color, r2->color)) @@ -685,7 +685,7 @@ int x64_reg_used(scf_register_t* r, scf_dag_node_t* dn) r2 = &(x64_registers[i]); - if (SCF_X64_REG_RSP == r2->id || SCF_X64_REG_RBP == r2->id) + if (!X64_COLOR_TYPE(r2->color) && (SCF_X64_REG_RSP == r2->id || SCF_X64_REG_RBP == r2->id)) continue; if (!X64_COLOR_CONFLICT(r->color, r2->color)) @@ -754,7 +754,7 @@ scf_register_t* x64_select_overflowed_reg(scf_dag_node_t* dn, scf_3ac_code_t* c) scf_register_t* r = &(x64_registers[i]); - if (SCF_X64_REG_RSP == r->id || SCF_X64_REG_RBP == r->id) + if (!X64_COLOR_TYPE(r->color) && (SCF_X64_REG_RSP == r->id || SCF_X64_REG_RBP == r->id)) continue; if (1 == bytes) { @@ -799,7 +799,7 @@ scf_register_t* x64_select_overflowed_reg(scf_dag_node_t* dn, scf_3ac_code_t* c) scf_register_t* r = &(x64_registers[i]); - if (SCF_X64_REG_RSP == r->id || SCF_X64_REG_RBP == r->id) + if (!X64_COLOR_TYPE(r->color) && (SCF_X64_REG_RSP == r->id || SCF_X64_REG_RBP == r->id)) continue; if (1 == bytes) { diff --git a/parse/main.c b/parse/main.c index c96968e..7e7d854 100644 --- a/parse/main.c +++ b/parse/main.c @@ -189,6 +189,7 @@ int main(int argc, char* argv[]) return -1; } + scf_logi("fname: %s\n", fname); if (scf_vector_add(vec, fname) < 0) return -ENOMEM; } @@ -233,25 +234,25 @@ int main(int argc, char* argv[]) return 0; } -#define MAIN_ADD_FILES(_objs, _sofiles) \ +#define MAIN_ADD_FILES(_objs, _sofiles, _arch) \ do { \ - int ret = add_sys_files(objs, sysroot, arch, _objs, sizeof(_objs) / sizeof(_objs[0])); \ + int ret = add_sys_files(objs, sysroot, _arch, _objs, sizeof(_objs) / sizeof(_objs[0])); \ if (ret < 0) \ return ret; \ \ - ret = add_sys_files(sofiles, sysroot, arch, _sofiles, sizeof(_sofiles) / sizeof(_sofiles[0])); \ + ret = add_sys_files(sofiles, sysroot, _arch, _sofiles, sizeof(_sofiles) / sizeof(_sofiles[0])); \ if (ret < 0) \ return ret; \ } while (0) if (!strcmp(arch, "arm64") || !strcmp(arch, "naja")) - MAIN_ADD_FILES(__arm64_objs, __arm64_sofiles); + MAIN_ADD_FILES(__arm64_objs, __arm64_sofiles, "arm64"); else if (!strcmp(arch, "arm32")) - MAIN_ADD_FILES(__arm32_objs, __arm32_sofiles); + MAIN_ADD_FILES(__arm32_objs, __arm32_sofiles, "arm32"); else - MAIN_ADD_FILES(__objs, __sofiles); + MAIN_ADD_FILES(__objs, __sofiles, "x64"); if (scf_vector_add(objs, obj) < 0) { diff --git a/parse/scf_dfa_async.c b/parse/scf_dfa_async.c index d6a826d..15f8340 100644 --- a/parse/scf_dfa_async.c +++ b/parse/scf_dfa_async.c @@ -35,14 +35,13 @@ static int _async_action_semicolon(scf_dfa_t* dfa, scf_vector_t* words, void* da { scf_parse_t* parse = dfa->priv; dfa_data_t* d = data; + scf_expr_t* e = d->expr; if (!d->expr) { scf_loge("\n"); return SCF_DFA_ERROR; } - scf_expr_t* e = d->expr; - while (SCF_OP_EXPR == e->type) { assert(e->nodes && 1 == e->nb_nodes); @@ -61,10 +60,13 @@ static int _async_action_semicolon(scf_dfa_t* dfa, scf_vector_t* words, void* da d->expr = NULL; d->expr_local_flag = 0; - scf_type_t* pt = NULL; - scf_function_t* f = NULL; + scf_type_t* t = NULL; + scf_function_t* f = NULL; + scf_variable_t* v = NULL; + scf_node_t* pf = NULL; + scf_node_t* fmt = NULL; - if (scf_ast_find_type_type(&pt, parse->ast, SCF_FUNCTION_PTR) < 0) + if (scf_ast_find_type_type(&t, parse->ast, SCF_FUNCTION_PTR) < 0) return SCF_DFA_ERROR; if (scf_ast_find_function(&f, parse->ast, "scf_async") < 0) @@ -74,26 +76,46 @@ static int _async_action_semicolon(scf_dfa_t* dfa, scf_vector_t* words, void* da return SCF_DFA_ERROR; } - scf_variable_t* var_pf = SCF_VAR_ALLOC_BY_TYPE(f->node.w, pt, 1, 1, f); - if (!var_pf) { + v = SCF_VAR_ALLOC_BY_TYPE(f->node.w, t, 1, 1, f); + if (!v) { + scf_loge("\n"); + return SCF_DFA_ERROR; + } + v->const_literal_flag = 1; + + pf = scf_node_alloc(d->current_async_w, v->type, v); + if (!pf) { + scf_loge("\n"); + return SCF_DFA_ERROR; + } + + if (scf_ast_find_type_type(&t, parse->ast, SCF_VAR_CHAR) < 0) + return SCF_DFA_ERROR; + + v = SCF_VAR_ALLOC_BY_TYPE(d->current_async_w, t, 1, 1, NULL); + if (!v) { scf_loge("\n"); return SCF_DFA_ERROR; } - var_pf->const_literal_flag = 1; + v->const_literal_flag = 1; + v->data.s = scf_string_cstr(""); - scf_node_t* node_pf = scf_node_alloc(d->current_async_w, var_pf->type, var_pf); - if (!node_pf) { + fmt = scf_node_alloc(d->current_async_w, v->type, v); + if (!fmt) { scf_loge("\n"); return SCF_DFA_ERROR; } - scf_node_add_child(e, node_pf); + scf_node_add_child(e, pf); + scf_node_add_child(e, fmt); int i; - for (i = e->nb_nodes - 2; i >= 0; i--) - e->nodes[i + 1] = e->nodes[i]; + for (i = e->nb_nodes - 3; i >= 0; i--) + e->nodes[i + 2] = e->nodes[i]; - e->nodes[0] = node_pf; + e->nodes[0] = pf; + e->nodes[1] = e->nodes[2]; + e->nodes[2] = fmt; if (d->current_node) scf_node_add_child(d->current_node, e); diff --git a/parse/scf_operator_handler_const.c b/parse/scf_operator_handler_const.c index eba7be0..d8a1037 100644 --- a/parse/scf_operator_handler_const.c +++ b/parse/scf_operator_handler_const.c @@ -133,7 +133,6 @@ static int _scf_op_const_create(scf_ast_t* ast, scf_node_t** nodes, int nb_nodes scf_function_t* callee2 = v2->func_ptr; if (caller != callee0) { - if (scf_vector_add_unique(caller->callee_functions, callee0) < 0) return -1; @@ -142,7 +141,6 @@ static int _scf_op_const_create(scf_ast_t* ast, scf_node_t** nodes, int nb_nodes } if (caller != callee2) { - if (scf_vector_add_unique(caller->callee_functions, callee2) < 0) return -1; @@ -170,7 +168,7 @@ static int _scf_op_const_array_index(scf_ast_t* ast, scf_node_t** nodes, int nb_ return -1; } - scf_handler_data_t* d = data; + scf_handler_data_t* d = data; int ret = _scf_expr_calculate_internal(ast, nodes[1], d); @@ -448,7 +446,6 @@ static int _scf_op_const_call(scf_ast_t* ast, scf_node_t** nodes, int nb_nodes, scf_function_t* callee = v0->func_ptr; if (caller != callee) { - if (scf_vector_add_unique(caller->callee_functions, callee) < 0) return -1; @@ -456,6 +453,16 @@ static int _scf_op_const_call(scf_ast_t* ast, scf_node_t** nodes, int nb_nodes, return -1; } + int i; + for (i = 1; i < nb_nodes; i++) { + + int ret = _scf_expr_calculate_internal(ast, nodes[i], data); + if (ret < 0) { + scf_loge("\n"); + return -1; + } + } + return 0; } @@ -578,7 +585,7 @@ static int _scf_op_const_type_cast(scf_ast_t* ast, scf_node_t** nodes, int nb_no if (scf_variable_integer(src) && scf_variable_integer(dst)) { int size; - if (src ->nb_dimentions > 0) + if (src->nb_dimentions > 0) size = sizeof(void*); else size = src->size; diff --git a/parse/scf_struct_array.c b/parse/scf_struct_array.c index dd06593..69d42a5 100644 --- a/parse/scf_struct_array.c +++ b/parse/scf_struct_array.c @@ -1,6 +1,41 @@ #include"scf_dfa.h" #include"scf_parse.h" +static int __reshape_index(dfa_index_t** out, scf_variable_t* array, dfa_index_t* index, int n) +{ + assert(array->nb_dimentions > 0); + assert(n > 0); + + dfa_index_t* p = calloc(array->nb_dimentions, sizeof(dfa_index_t)); + if (!p) + return -ENOMEM; + + intptr_t i = index[n - 1].i; + + scf_logw("reshape 'init exprs' from %d-dimention to %d-dimention, origin last index: %ld\n", + n, array->nb_dimentions, i); + + int j; + for (j = array->nb_dimentions - 1; j >= 0; j--) { + + if (array->dimentions[j] <= 0) { + scf_logw("array's %d-dimention size not set, file: %s, line: %d\n", j, array->w->file->data, array->w->line); + + free(p); + return -1; + } + + p[j].i = i % array->dimentions[j]; + i = i / array->dimentions[j]; + } + + for (j = 0; j < array->nb_dimentions; j++) + scf_logi("\033[32m dim: %d, size: %d, index: %ld\033[0m\n", j, array->dimentions[j], p[j].i); + + *out = p; + return 0; +} + static int __array_member_init(scf_ast_t* ast, scf_lex_word_t* w, scf_variable_t* array, dfa_index_t* index, int n, scf_node_t** pnode) { if (!pnode) @@ -13,9 +48,15 @@ static int __array_member_init(scf_ast_t* ast, scf_lex_word_t* w, scf_variable_t root = scf_node_alloc(NULL, array->type, array); if (n < array->nb_dimentions) { - scf_loge("number of indexes less than needed, array '%s', file: %s, line: %d\n", - array->w->text->data, w->file->data, w->line); - return -1; + if (n <= 0) { + scf_loge("number of indexes less than needed, array '%s', file: %s, line: %d\n", + array->w->text->data, w->file->data, w->line); + return -1; + } + + int ret = __reshape_index(&index, array, index, n); + if (ret < 0) + return ret; } int i; @@ -26,6 +67,11 @@ static int __array_member_init(scf_ast_t* ast, scf_lex_word_t* w, scf_variable_t if (k >= array->dimentions[i]) { scf_loge("index [%ld] out of size [%d], in dim: %d, file: %s, line: %d\n", k, array->dimentions[i], i, w->file->data, w->line); + + if (n < array->nb_dimentions) { + free(index); + index = NULL; + } return -1; } @@ -42,6 +88,11 @@ static int __array_member_init(scf_ast_t* ast, scf_lex_word_t* w, scf_variable_t root = node_op; } + if (n < array->nb_dimentions) { + free(index); + index = NULL; + } + *pnode = root; return array->nb_dimentions; } @@ -179,31 +230,33 @@ int scf_array_member_init(scf_ast_t* ast, scf_lex_word_t* w, scf_variable_t* arr return n; } -int scf_array_init(scf_ast_t* ast, scf_lex_word_t* w, scf_variable_t* var, scf_vector_t* init_exprs) +int scf_array_init(scf_ast_t* ast, scf_lex_word_t* w, scf_variable_t* v, scf_vector_t* init_exprs) { dfa_init_expr_t* ie; int unset = 0; int unset_dim = -1; + int capacity = 1; int i; int j; - for (i = 0; i < var->nb_dimentions; i++) { - assert(var->dimentions); + for (i = 0; i < v->nb_dimentions; i++) { + assert(v->dimentions); - scf_logi("dim[%d]: %d\n", i, var->dimentions[i]); + scf_logi("dim[%d]: %d\n", i, v->dimentions[i]); - if (var->dimentions[i] < 0) { + if (v->dimentions[i] < 0) { if (unset > 0) { scf_loge("array '%s' should only unset 1-dimention size, file: %s, line: %d\n", - var->w->text->data, w->file->data, w->line); + v->w->text->data, w->file->data, w->line); return -1; } unset++; unset_dim = i; - } + } else + capacity *= v->dimentions[i]; } if (unset) { @@ -212,22 +265,50 @@ int scf_array_init(scf_ast_t* ast, scf_lex_word_t* w, scf_variable_t* var, scf_v for (i = 0; i < init_exprs->size; i++) { ie = init_exprs->data[i]; - if (unset_max < ie->index[unset_dim].i) - unset_max = ie->index[unset_dim].i; + if (unset_dim < ie->n) { + if (unset_max < ie->index[unset_dim].i) + unset_max = ie->index[unset_dim].i; + } } - var->dimentions[unset_dim] = unset_max + 1; + if (-1 == unset_max) { + unset_max = init_exprs->size / capacity; + + v->dimentions[unset_dim] = unset_max; + + scf_logw("don't set %d-dimention size of array '%s', use '%d' as calculated, file: %s, line: %d\n", + unset_dim, v->w->text->data, unset_max, w->file->data, w->line); + } else + v->dimentions[unset_dim] = unset_max + 1; } for (i = 0; i < init_exprs->size; i++) { ie = init_exprs->data[i]; - for (j = 0; j < var->nb_dimentions; j++) { + if (ie->n < v->nb_dimentions) { + int n = ie->n; + + void* p = realloc(ie, sizeof(dfa_init_expr_t) + sizeof(dfa_index_t) * v->nb_dimentions); + if (!p) + return -ENOMEM; + init_exprs->data[i] = p; + + ie = p; + ie->n = v->nb_dimentions; - intptr_t index = ie->index[j].i; + intptr_t index = ie->index[n - 1].i; - scf_logi("\033[32mi: %d, dim: %d, size: %d, index: %ld\033[0m\n", i, j, var->dimentions[j], index); + scf_logw("reshape 'init exprs' from %d-dimention to %d-dimention, origin last index: %ld\n", n, v->nb_dimentions, index); + + for (j = v->nb_dimentions - 1; j >= 0; j--) { + + ie->index[j].i = index % v->dimentions[j]; + index = index / v->dimentions[j]; + } } + + for (j = 0; j < v->nb_dimentions; j++) + scf_logi("\033[32mi: %d, dim: %d, size: %d, index: %ld\033[0m\n", i, j, v->dimentions[j], ie->index[j].i); } for (i = 0; i < init_exprs->size; i++) { @@ -239,7 +320,7 @@ int scf_array_init(scf_ast_t* ast, scf_lex_word_t* w, scf_variable_t* var, scf_v scf_node_t* assign; scf_node_t* node = NULL; - if (scf_array_member_init(ast, w, var, ie->index, ie->n, &node) < 0) { + if (scf_array_member_init(ast, w, v, ie->index, ie->n, &node) < 0) { scf_loge("\n"); return -1; } diff --git a/util/scf_rbtree.c b/util/scf_rbtree.c index d4dd534..825f168 100644 --- a/util/scf_rbtree.c +++ b/util/scf_rbtree.c @@ -725,4 +725,3 @@ int main() return 0; } #endif - diff --git a/vm/scf_vm_naja.c b/vm/scf_vm_naja.c index de0eb16..d98eb32 100644 --- a/vm/scf_vm_naja.c +++ b/vm/scf_vm_naja.c @@ -188,9 +188,9 @@ int naja_vm_init(scf_vm_t* vm, const char* path, const char* sys) return -1; } - scf_loge("i: %d, ph->p_offset: %#lx, ph->p_filesz: %#lx\n", i, ph->ph.p_offset, ph->ph.p_filesz); + scf_logi("i: %d, ph->p_offset: %#lx, ph->p_filesz: %#lx\n", i, ph->ph.p_offset, ph->ph.p_filesz); - scf_loge("i: %d, ph->addr: %#lx, ph->len: %#lx, %#lx, ph->flags: %#x\n", i, ph->addr, ph->len, ph->ph.p_memsz, ph->ph.p_flags); + scf_logi("i: %d, ph->addr: %#lx, ph->len: %#lx, %#lx, ph->flags: %#x\n", i, ph->addr, ph->len, ph->ph.p_memsz, ph->ph.p_flags); if ((PF_X | PF_R) == ph->ph.p_flags) vm->text = ph; @@ -211,11 +211,11 @@ int naja_vm_init(scf_vm_t* vm, const char* path, const char* sys) vm->dynamic = ph; - scf_loge("ph->addr: %#lx, ph->len: %#lx, %#lx, ph->p_offset: %#lx\n", ph->addr, ph->len, ph->ph.p_memsz, ph->ph.p_offset); + scf_logi("ph->addr: %#lx, ph->len: %#lx, %#lx, ph->p_offset: %#lx\n", ph->addr, ph->len, ph->ph.p_memsz, ph->ph.p_offset); } } - scf_loge("\n\n"); + scf_logi("\n\n"); if (vm->dynamic) { Elf64_Dyn* d = (Elf64_Dyn*)(vm->data->data + vm->dynamic->ph.p_offset); @@ -226,23 +226,23 @@ int naja_vm_init(scf_vm_t* vm, const char* path, const char* sys) switch (d[i].d_tag) { case DT_STRTAB: - scf_loge("dynstr: %#lx\n", d[i].d_un.d_ptr); + scf_logi("dynstr: %#lx\n", d[i].d_un.d_ptr); vm->dynstr = d[i].d_un.d_ptr - vm->text->addr + vm->text->data; break; case DT_SYMTAB: - scf_loge("dynsym: %#lx\n", d[i].d_un.d_ptr); + scf_logi("dynsym: %#lx\n", d[i].d_un.d_ptr); vm->dynsym = (Elf64_Sym*)(d[i].d_un.d_ptr - vm->text->addr + vm->text->data); break; case DT_JMPREL: - scf_loge("JMPREL: %#lx\n", d[i].d_un.d_ptr); + scf_logi("JMPREL: %#lx\n", d[i].d_un.d_ptr); vm->jmprel = (Elf64_Rela*)(d[i].d_un.d_ptr - vm->text->addr + vm->text->data); vm->jmprel_addr = d[i].d_un.d_ptr; break; case DT_PLTGOT: - scf_loge("PLTGOT: %#lx\n", d[i].d_un.d_ptr); + scf_logi("PLTGOT: %#lx\n", d[i].d_un.d_ptr); vm->pltgot = (uint64_t*)(d[i].d_un.d_ptr - vm->data->addr + vm->data->data); break; @@ -267,7 +267,7 @@ int naja_vm_init(scf_vm_t* vm, const char* path, const char* sys) } } - scf_loge("needed: %s\n", name); + scf_logi("needed: %s\n", name); void* so = dlopen(name, RTLD_LAZY); if (!so) { -- 2.25.1