[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Guile-commits] 15/86: Remove unneeded bits of lightning
From: |
Andy Wingo |
Subject: |
[Guile-commits] 15/86: Remove unneeded bits of lightning |
Date: |
Wed, 3 Apr 2019 11:38:50 -0400 (EDT) |
wingo pushed a commit to branch lightening
in repository guile.
commit 90ebba864a090c9901723e4ce739cfc698294672
Author: Andy Wingo <address@hidden>
Date: Tue Oct 30 12:32:26 2018 +0100
Remove unneeded bits of lightning
---
jit/disasm.c | 415 -----------------------------------------------------------
jit/memory.c | 124 ------------------
jit/names.c | 230 ---------------------------------
jit/note.c | 414 ----------------------------------------------------------
jit/print.c | 367 ----------------------------------------------------
jit/rewind.c | 192 ---------------------------
jit/size.c | 130 -------------------
7 files changed, 1872 deletions(-)
diff --git a/jit/disasm.c b/jit/disasm.c
deleted file mode 100644
index fa33772..0000000
--- a/jit/disasm.c
+++ /dev/null
@@ -1,415 +0,0 @@
-/*
- * Copyright (C) 2012-2018 Free Software Foundation, Inc.
- *
- * This file is part of GNU lightning.
- *
- * GNU lightning is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation; either version 3, or (at your option)
- * any later version.
- *
- * GNU lightning is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * Authors:
- * Paulo Cesar Pereira de Andrade
- */
-
-#include "jit.h"
-#include "jit/jit_private.h"
-#if DISASSEMBLER
-# include <dis-asm.h>
-#endif
-
-/*
- * Prototypes
- */
-#if DISASSEMBLER
-static int
-disasm_compare_symbols(const void *ap, const void *bp);
-
-static void
-disasm_print_address(bfd_vma addr, struct disassemble_info *info);
-
-#define disassemble(u, v) _disassemble(_jit, u, v)
-static void
-_disassemble(jit_state_t *_jit, jit_pointer_t code, jit_int32_t length);
-#endif
-
-/*
- * Initialization
- */
-#if DISASSEMBLER
-static bfd *disasm_bfd;
-static disassemble_info disasm_info;
-static disassembler_ftype disasm_print;
-static asymbol **disasm_symbols;
-static asymbol *disasm_synthetic;
-static long disasm_num_symbols;
-static long disasm_num_synthetic;
-static jit_state_t *disasm_jit;
-#define disasm_stream stdout
-#endif
-
-/*
- * Implementation
- */
-void
-jit_init_debug(const char *progname)
-{
-#if DISASSEMBLER
- bfd_init();
-
- if (progname)
- disasm_bfd = bfd_openr(progname, NULL);
- if (disasm_bfd == NULL) {
-#if defined(__linux__)
- disasm_bfd = bfd_openr("/proc/self/exe", NULL);
- if (disasm_bfd == NULL)
-#endif
- return;
- }
- bfd_check_format(disasm_bfd, bfd_object);
- bfd_check_format(disasm_bfd, bfd_archive);
- INIT_DISASSEMBLE_INFO(disasm_info, disasm_stream, fprintf);
-# if defined(__i386__) || defined(__x86_64__)
- disasm_info.arch = bfd_arch_i386;
-# if defined(__x86_64__)
-# if __WORDSIZE == 32
- disasm_info.mach = bfd_mach_x64_32;
-# else
- disasm_info.mach = bfd_mach_x86_64;
-# endif
-# else
- disasm_info.mach = bfd_mach_i386_i386;
-# endif
-# endif
-# if defined(__powerpc__)
- disasm_info.arch = bfd_arch_powerpc;
- disasm_info.mach = bfd_mach_ppc64;
-# if HAVE_DISASSEMBLE_INIT_FOR_TARGET
- disassemble_init_for_target(&disasm_info);
-# elif HAVE_DISASSEMBLE_INIT_POWERPC
- disassemble_init_powerpc(&disasm_info);
-# endif
-# if defined(__powerpc64__)
- disasm_info.disassembler_options = "64";
-# endif
-# if HAVE_DISASSEMBLE_INIT_FOR_TARGET
- disassemble_init_for_target(&disasm_info);
-# elif HAVE_DISASSEMBLE_INIT_POWERPC
- disassemble_init_powerpc(&disasm_info);
-# endif
-# endif
-# if defined(__sparc__)
- disasm_info.endian = disasm_info.display_endian = BFD_ENDIAN_BIG;
-# endif
-# if defined(__s390__) || defined(__s390x__)
- disasm_info.arch = bfd_arch_s390;
-# if __WORDSIZE == 32
- disasm_info.mach = bfd_mach_s390_31;
-# else
- disasm_info.mach = bfd_mach_s390_64;
-# endif
- disasm_info.endian = disasm_info.display_endian = BFD_ENDIAN_BIG;
- disasm_info.disassembler_options = "zarch";
-# endif
-# if defined(__alpha__)
- disasm_info.arch = bfd_arch_alpha;
- disasm_info.mach = bfd_mach_alpha_ev6;
-# endif
- disasm_info.print_address_func = disasm_print_address;
-
-# if BINUTILS_2_29
- disasm_print = disassembler(disasm_info.arch, __BYTE_ORDER == __BIG_ENDIAN,
- disasm_info.mach, disasm_bfd);
-# else
- disasm_print = disassembler(disasm_bfd);
-# endif
- assert(disasm_print);
-
- if (bfd_get_file_flags(disasm_bfd) & HAS_SYMS) {
- asymbol **in;
- asymbol **out;
- asymbol *symbol;
- long offset;
- long sym_count;
- long dyn_count;
- long sym_storage;
- long dyn_storage;
-
- if ((sym_storage = bfd_get_symtab_upper_bound(disasm_bfd)) >= 0) {
-
- if (bfd_get_file_flags(disasm_bfd) & DYNAMIC) {
- dyn_storage = bfd_get_dynamic_symtab_upper_bound(disasm_bfd);
-# if defined(__alpha__)
- /* XXX */
- if (dyn_storage < 0)
- dyn_storage = 0;
-# else
- assert(dyn_storage >= 0);
-# endif
- }
- else
- dyn_storage = 0;
-
- jit_alloc((jit_pointer_t *)&disasm_symbols,
- (sym_storage + dyn_storage) * sizeof(asymbol *));
- sym_count = bfd_canonicalize_symtab(disasm_bfd, disasm_symbols);
- assert(sym_count >= 0);
- if (dyn_storage) {
- dyn_count = bfd_canonicalize_dynamic_symtab(disasm_bfd,
- disasm_symbols +
- sym_count);
- assert(dyn_count >= 0);
- }
- else
- dyn_count = 0;
- disasm_num_symbols = sym_count + dyn_count;
-
- disasm_num_synthetic = bfd_get_synthetic_symtab(disasm_bfd,
- sym_count,
- disasm_symbols,
- dyn_count,
- disasm_symbols +
- sym_count,
- &disasm_synthetic);
- if (disasm_num_synthetic > 0) {
- jit_realloc((jit_pointer_t *)&disasm_symbols,
- (sym_storage + dyn_storage) * sizeof(asymbol *),
- (sym_storage + dyn_storage + disasm_num_synthetic) *
- sizeof(asymbol *));
- for (offset = 0; offset < disasm_num_synthetic; offset++)
- disasm_symbols[disasm_num_symbols++] =
- disasm_synthetic + offset;
- }
-
- /* remove symbols not useful for disassemble */
- in = out = disasm_symbols;
- for (offset = 0; offset < disasm_num_symbols; offset++) {
- symbol = *in++;
- if (symbol->name &&
- symbol->name[0] != '\0' &&
- !(symbol->flags & (BSF_DEBUGGING | BSF_SECTION_SYM)) &&
- !bfd_is_und_section(symbol->section) &&
- !bfd_is_com_section(symbol->section))
- *out++ = symbol;
- }
- disasm_num_symbols = out - disasm_symbols;
- qsort(disasm_symbols, disasm_num_symbols,
- sizeof(asymbol *), disasm_compare_symbols);
- }
- }
-#endif
-}
-
-void
-jit_finish_debug(void)
-{
-#if DISASSEMBLER
- if (disasm_synthetic)
- jit_free((jit_pointer_t *)&disasm_synthetic);
- if (disasm_symbols)
- jit_free((jit_pointer_t *)&disasm_symbols);
-#endif
-}
-
-void
-_jit_disassemble(jit_state_t *_jit)
-{
-#if DISASSEMBLER
- if (disasm_bfd) {
-# if defined(__arm__)
- /* FIXME add mapping for prolog switching to arm and possible jump
- * before first prolog also in arm mode */
- disasm_info.disassembler_options = jit_cpu.thumb ? "force-thumb" : "";
-# endif
-
- disassemble(_jit->code.ptr, _jit->pc.uc - _jit->code.ptr);
- }
-#endif
-}
-
-#if DISASSEMBLER
-/* Based on objdump source */
-static int
-disasm_compare_symbols(const void *ap, const void *bp)
-{
- const asymbol *a = *(const asymbol **)ap;
- const asymbol *b = *(const asymbol **)bp;
-
- if (bfd_asymbol_value(a) > bfd_asymbol_value(b))
- return (1);
- if (bfd_asymbol_value(a) < bfd_asymbol_value(b))
- return (-1);
- return (0);
-}
-
-#if __WORDSIZE == 32
-# define address_buffer_length 16
-# define address_buffer_format "%llx"
-#else
-# define address_buffer_length 32
-# define address_buffer_format "%lx"
-#endif
-static void
-disasm_print_address(bfd_vma addr, struct disassemble_info *info)
-{
- char *name;
- char *file;
- int line;
- char buffer[address_buffer_length];
-
- sprintf(buffer, address_buffer_format, (long long)addr);
- (*info->fprintf_func)(info->stream, "0x%s", buffer);
-
-# define _jit disasm_jit
-# undef jit_pointer_p
-# define jit_pointer_p(u) \
- ((u) >= _jit->code.ptr && (u) < _jit->pc.uc)
- if (jit_pointer_p((jit_uint8_t *)(jit_word_t)addr)) {
- if (jit_get_note((jit_uint8_t *)(jit_word_t)addr, &name, &file, &line))
- (*info->fprintf_func)(info->stream, " %s:%s:%d",
- name ? name : "",
- file ? file : "",
- line);
- }
-# undef jit_pointer_p
-# undef _jit
- else if (disasm_num_symbols) {
- long low;
- long high;
- long offset;
- asymbol *symbol;
-
- low = 0;
- high = disasm_num_symbols;
- do {
- offset = (low + high) >> 1;
- symbol = disasm_symbols[offset];
- if (bfd_asymbol_value(symbol) > addr)
- high = offset - 1;
- else if (bfd_asymbol_value(symbol) < addr)
- low = offset + 1;
- else
- break;
- } while (low < high);
-
- if (offset >= 0 && offset < disasm_num_symbols) {
- if (bfd_asymbol_value(symbol) < addr) {
- while (++offset < disasm_num_symbols) {
- symbol = disasm_symbols[offset];
- if (bfd_asymbol_value(symbol) >= addr)
- break;
- }
- }
- else if (bfd_asymbol_value(symbol) > addr) {
- while (offset--) {
- if (bfd_asymbol_value(disasm_symbols[offset]) < addr)
- break;
- symbol = disasm_symbols[offset];
- }
- }
- if (bfd_asymbol_value(symbol) == addr)
- (*info->fprintf_func)(info->stream, " # %s", symbol->name);
- }
- }
-}
-
-static void
-_disassemble(jit_state_t *_jit, jit_pointer_t code, jit_int32_t length)
-{
- int bytes;
- char *name, *old_name;
- char *file, *old_file;
- int line, old_line;
-#if __arm__
- jit_int32_t offset;
- jit_bool_t data_info;
- jit_int32_t data_offset;
-#endif
- bfd_vma pc = (jit_uword_t)code;
- bfd_vma end = (jit_uword_t)code + length;
- char buffer[address_buffer_length];
-#if DEVEL_DISASSEMBLER
- jit_node_t *node;
- jit_uword_t prevw;
-#endif
-
-#if __arm__
- data_info = _jitc && _jitc->data_info.ptr;
- data_offset = 0;
-#endif
- disasm_info.buffer = code;
- disasm_info.buffer_vma = (jit_uword_t)code;
- disasm_info.buffer_length = length;
- old_file = old_name = NULL;
- old_line = 0;
- disasm_jit = _jit;
-#if DEVEL_DISASSEMBLER
- node = _jitc->head;
- prevw = pc;
-#endif
- while (pc < end) {
-#if DEVEL_DISASSEMBLER
- while (node && (jit_uword_t)(prevw + node->offset) < (jit_uword_t)pc) {
- prevw += node->offset;
- node = node->next;
- }
- while (node && (jit_uword_t)(prevw + node->offset) == (jit_uword_t)pc) {
- jit_print_node(node);
- fputc('\n', stdout);
- prevw += node->offset;
- node = node->next;
- }
-#endif
-#if __arm__
- again:
- if (data_info) {
- while (_jitc->data_info.ptr[data_offset].code < pc) {
- if (++data_offset >= _jitc->data_info.length) {
- data_info = 0;
- goto again;
- }
- }
- if (pc == _jitc->data_info.ptr[data_offset].code) {
- offset = _jitc->data_info.ptr[data_offset].length;
- for (; offset >= 4; offset -= 4, pc += 4) {
- bytes = sprintf(buffer, address_buffer_format, pc);
- (*disasm_info.fprintf_func)(disasm_stream,
- "%*c0x%s\t.data\t0x%08x\n",
- 16 - bytes, ' ', buffer,
- *(jit_uint32_t *)
- (jit_uint32_t)pc);
- }
- /* reset disassemble information instead of attempting
- * to hack the arm specific backend data structures to
- * tell it to forward the required number of bytes. */
- disasm_info.buffer = (jit_pointer_t)(jit_uint32_t)pc;
- disasm_info.buffer_vma = (jit_uword_t)pc;
- if ((disasm_info.buffer_length = end - pc) <= 0)
- break;
- }
- }
-#endif
- if (jit_get_note((jit_uint8_t *)(jit_word_t)pc, &name, &file, &line) &&
- (name != old_name || file != old_file || line != old_line)) {
- (*disasm_info.fprintf_func)(disasm_stream, "# %s:%s:%d\n",
- name ? name : "",
- file ? file : "",
- line);
- old_name = name;
- old_file = file;
- old_line = line;
- }
-
- bytes = sprintf(buffer, address_buffer_format, (long long)pc);
- (*disasm_info.fprintf_func)(disasm_stream, "%*c0x%s\t",
- 16 - bytes, ' ', buffer);
- pc += (*disasm_print)(pc, &disasm_info);
- putc('\n', disasm_stream);
- }
-}
-#endif
diff --git a/jit/memory.c b/jit/memory.c
deleted file mode 100644
index b2a90ef..0000000
--- a/jit/memory.c
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * Copyright (C) 2013-2018 Free Software Foundation, Inc.
- *
- * This file is part of GNU lightning.
- *
- * GNU lightning is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation; either version 3, or (at your option)
- * any later version.
- *
- * GNU lightning is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * Authors:
- * Paulo Cesar Pereira de Andrade
- */
-
-#include <sys/mman.h>
-
-#include "jit.h"
-#include "jit/jit_private.h"
-
-/*
- * Prototypes
- */
-static void *jit_default_alloc_func(size_t);
-static void *jit_default_realloc_func(void*, size_t);
-static void jit_default_free_func(void *);
-
-/*
- * Initialization
- */
-static jit_alloc_func_ptr jit_alloc_ptr = jit_default_alloc_func;
-static jit_realloc_func_ptr jit_realloc_ptr = jit_default_realloc_func;
-static jit_free_func_ptr jit_free_ptr = jit_default_free_func;
-
-/*
- * Implementation
- */
-jit_pointer_t
-jit_memcpy(jit_pointer_t dst, const void * src, jit_word_t size)
-{
- if (size)
- return (memcpy(dst, src, size));
- return (dst);
-}
-
-jit_pointer_t
-jit_memmove(jit_pointer_t dst, const void *src , jit_word_t size)
-{
- if (size)
- return (memmove(dst, src, size));
- return (dst);
-}
-
-void
-jit_set_memory_functions(jit_alloc_func_ptr alloc_ptr,
- jit_realloc_func_ptr realloc_ptr,
- jit_free_func_ptr free_ptr)
-{
- if (alloc_ptr == NULL)
- alloc_ptr = jit_default_alloc_func;
- if (realloc_ptr == NULL)
- realloc_ptr = jit_default_realloc_func;
- if (free_ptr == NULL)
- free_ptr = jit_default_free_func;
- jit_alloc_ptr = alloc_ptr;
- jit_realloc_ptr = realloc_ptr;
- jit_free_ptr = free_ptr;
-}
-
-void
-jit_get_memory_functions(jit_alloc_func_ptr *alloc_ptr,
- jit_realloc_func_ptr *realloc_ptr,
- jit_free_func_ptr *free_ptr)
-{
- *alloc_ptr = jit_alloc_ptr;
- *realloc_ptr = jit_realloc_ptr;
- *free_ptr = jit_free_ptr;
-}
-
-void
-jit_alloc(jit_pointer_t *ptr, jit_word_t size)
-{
- *ptr = (*jit_alloc_ptr)(size);
- memset(*ptr, 0, size);
-}
-
-void
-jit_realloc(jit_pointer_t *ptr, jit_word_t old_size, jit_word_t new_size)
-{
- *ptr = (*jit_realloc_ptr)(*ptr, new_size);
- if (old_size < new_size)
- memset((jit_int8_t*)*ptr + old_size, 0, new_size - old_size);
-}
-
-void
-jit_free(jit_pointer_t *ptr)
-{
- if (*ptr) {
- (*jit_free_ptr)(*ptr);
- *ptr = NULL;
- }
-}
-
-static void *
-jit_default_alloc_func(size_t size)
-{
- return (malloc(size));
-}
-
-static void *
-jit_default_realloc_func(void *ptr, size_t size)
-{
- return (realloc(ptr, size));
-}
-
-static void
-jit_default_free_func(void *ptr)
-{
- free(ptr);
-}
diff --git a/jit/names.c b/jit/names.c
deleted file mode 100644
index ba09a6a..0000000
--- a/jit/names.c
+++ /dev/null
@@ -1,230 +0,0 @@
-/*
- * Copyright (C) 2014-2017 Free Software Foundation, Inc.
- *
- * This file is part of GNU lightning.
- *
- * GNU lightning is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation; either version 3, or (at your option)
- * any later version.
- *
- * GNU lightning is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * Authors:
- * Paulo Cesar Pereira de Andrade
- */
-
-static char *code_name[] = {
- "data",
- "live", "align",
- "save", "load",
- "#name", "#note",
- "label",
- "prolog",
- "ellipsis", "va_push",
- "allocai", "allocar",
- "arg",
- "getarg_c", "getarg_uc",
- "getarg_s", "getarg_us",
- "getarg_i", "getarg_ui",
- "getarg_l",
- "putargr", "putargi",
- "va_start",
- "va_arg", "va_arg_d",
- "va_end",
- "addr", "addi",
- "addcr", "addci",
- "addxr", "addxi",
- "subr", "subi",
- "subcr", "subci",
- "subxr", "subxi",
- "rsbi",
- "mulr", "muli",
- "qmulr", "qmuli",
- "qmulr_u", "qmuli_u",
- "divr", "divi",
- "divr_u", "divi_u",
- "qdivr", "qdivi",
- "qdivr_u", "qdivi_u",
- "remr", "remi",
- "remr_u", "remi_u",
- "andr", "andi",
- "orr", "ori",
- "xorr", "xori",
- "lshr", "lshi",
- "rshr", "rshi",
- "rshr_u", "rshi_u",
- "negr", "comr",
- "ltr", "lti",
- "ltr_u", "lti_u",
- "ler", "lei",
- "ler_u", "lei_u",
- "eqr", "eqi",
- "ger", "gei",
- "ger_u", "gei_u",
- "gtr", "gti",
- "gtr_u", "gti_u",
- "ner", "nei",
- "movr", "movi",
- "extr_c", "extr_uc",
- "extr_s", "extr_us",
- "extr_i", "extr_ui",
- "htonr_us",
- "htonr_ui", "htonr_ul",
- "ldr_c", "ldi_c",
- "ldr_uc", "ldi_uc",
- "ldr_s", "ldi_s",
- "ldr_us", "ldi_us",
- "ldr_i", "ldi_i",
- "ldr_ui", "ldi_ui",
- "ldr_l", "ldi_l",
- "ldxr_c", "ldxi_c",
- "ldxr_uc", "ldxi_uc",
- "ldxr_s", "ldxi_s",
- "ldxr_us", "ldxi_us",
- "ldxr_i", "ldxi_i",
- "ldxr_ui", "ldxi_ui",
- "ldxr_l", "ldxi_l",
- "str_c", "sti_c",
- "str_s", "sti_s",
- "str_i", "sti_i",
- "str_l", "sti_l",
- "stxr_c", "stxi_c",
- "stxr_s", "stxi_s",
- "stxr_i", "stxi_i",
- "stxr_l", "stxi_l",
- "bltr", "blti",
- "bltr_u", "blti_u",
- "bler", "blei",
- "bler_u", "blei_u",
- "beqr", "beqi",
- "bger", "bgei",
- "bger_u", "bgei_u",
- "bgtr", "bgti",
- "bgtr_u", "bgti_u",
- "bner", "bnei",
- "bmsr", "bmsi",
- "bmcr", "bmci",
- "boaddr", "boaddi",
- "boaddr_u", "boaddi_u",
- "bxaddr", "bxaddi",
- "bxaddr_u", "bxaddi_u",
- "bosubr", "bosubi",
- "bosubr_u", "bosubi_u",
- "bxsubr", "bxsubi",
- "bxsubr_u", "bxsubi_u",
- "jmpr", "jmpi",
- "callr", "calli",
- "prepare",
- "pushargr", "pushargi",
- "finishr", "finishi",
- "ret",
- "retr", "reti",
- "retval_c", "retval_uc",
- "retval_s", "retval_us",
- "retval_i", "retval_ui",
- "retval_l",
- "epilog",
- "arg_f", "getarg_f",
- "putargr_f", "putargi_f",
- "addr_f", "addi_f",
- "subr_f", "subi_f",
- "rsbi_f",
- "mulr_f", "muli_f",
- "divr_f", "divi_f",
- "negr_f", "absr_f",
- "sqrtr_f",
- "ltr_f", "lti_f",
- "ler_f", "lei_f",
- "eqr_f", "eqi_f",
- "ger_f", "gei_f",
- "gtr_f", "gti_f",
- "ner_f", "nei_f",
- "unltr_f", "unlti_f",
- "unler_f", "unlei_f",
- "uneqr_f", "uneqi_f",
- "unger_f", "ungei_f",
- "ungtr_f", "ungti_f",
- "ltgtr_f", "ltgti_f",
- "ordr_f", "ordi_f",
- "unordr_f", "unordi_f",
- "truncr_f_i", "truncr_f_l",
- "extr_f", "extr_d_f",
- "movr_f", "movi_f",
- "ldr_f", "ldi_f",
- "ldxr_f", "ldxi_f",
- "str_f", "sti_f",
- "stxr_f", "stxi_f",
- "bltr_f", "blti_f",
- "bler_f", "blei_f",
- "beqr_f", "beqi_f",
- "bger_f", "bgei_f",
- "bgtr_f", "bgti_f",
- "bner_f", "bnei_f",
- "bunltr_f", "bunlti_f",
- "bunler_f", "bunlei_f",
- "buneqr_f", "buneqi_f",
- "bunger_f", "bungei_f",
- "bungtr_f", "bungti_f",
- "bltgtr_f", "bltgti_f",
- "bordr_f", "bordi_f",
- "bunordr_f", "bunordi_f",
- "pushargr_f", "pushargi_f",
- "retr_f", "reti_f",
- "retval_f",
- "arg_d", "getarg_d",
- "putargr_d", "putargi_d",
- "addr_d", "addi_d",
- "subr_d", "subi_d",
- "rsbi_d",
- "mulr_d", "muli_d",
- "divr_d", "divi_d",
- "negr_d", "absr_d",
- "sqrtr_d",
- "ltr_d", "lti_d",
- "ler_d", "lei_d",
- "eqr_d", "eqi_d",
- "ger_d", "gei_d",
- "gtr_d", "gti_d",
- "ner_d", "nei_d",
- "unltr_d", "unlti_d",
- "unler_d", "unlei_d",
- "uneqr_d", "uneqi_d",
- "unger_d", "ungei_d",
- "ungtr_d", "ungti_d",
- "ltgtr_d", "ltgti_d",
- "ordr_d", "ordi_d",
- "unordr_d", "unordi_d",
- "truncr_d_i", "truncr_d_l",
- "extr_d", "extr_f_d",
- "movr_d", "movi_d",
- "ldr_d", "ldi_d",
- "ldxr_d", "ldxi_d",
- "str_d", "sti_d",
- "stxr_d", "stxi_d",
- "bltr_d", "blti_d",
- "bler_d", "blei_d",
- "beqr_d", "beqi_d",
- "bger_d", "bgei_d",
- "bgtr_d", "bgti_d",
- "bner_d", "bnei_d",
- "bunltr_d", "bunlti_d",
- "bunler_d", "bunlei_d",
- "buneqr_d", "buneqi_d",
- "bunger_d", "bungei_d",
- "bungtr_d", "bungti_d",
- "bltgtr_d", "bltgti_d",
- "bordr_d", "bordi_d",
- "bunordr_d", "bunordi_d",
- "pushargr_d", "pushargi_d",
- "retr_d", "reti_d",
- "retval_d",
- "movr_w_f", "movr_ww_d",
- "movr_w_d",
- "movr_f_w", "movi_f_w",
- "movr_d_ww", "movi_d_ww",
- "movr_d_w", "movi_d_w",
-};
diff --git a/jit/note.c b/jit/note.c
deleted file mode 100644
index ced3506..0000000
--- a/jit/note.c
+++ /dev/null
@@ -1,414 +0,0 @@
-/*
- * Copyright (C) 2013-2018 Free Software Foundation, Inc.
- *
- * This file is part of GNU lightning.
- *
- * GNU lightning is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation; either version 3, or (at your option)
- * any later version.
- *
- * GNU lightning is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * Authors:
- * Paulo Cesar Pereira de Andrade
- */
-
-#include "jit.h"
-#include "jit/jit_private.h"
-
-/*
- * Prototypes
- */
-#define new_note(u, v) _new_note(_jit, u, v)
-static jit_note_t *_new_note(jit_state_t *, jit_uint8_t*, char*);
-static void new_line(jit_int32_t,jit_note_t*,char*,jit_int32_t,jit_int32_t);
-#define note_search_index(u) _note_search_index(_jit, u)
-static jit_int32_t _note_search_index(jit_state_t*, jit_uint8_t*);
-static jit_int32_t line_insert_index(jit_note_t*,jit_int32_t);
-static jit_int32_t line_search_index(jit_note_t*,jit_int32_t);
-static jit_int32_t offset_insert_index(jit_line_t*,jit_int32_t);
-static jit_int32_t offset_search_index(jit_line_t*,jit_int32_t);
-
-/*
- * Implementation
- */
-void
-jit_init_note(void)
-{
-}
-
-void
-jit_finish_note(void)
-{
-}
-
-jit_node_t *
-_jit_name(jit_state_t *_jit, const char *name)
-{
- jit_node_t *node;
-
- node = jit_new_node(jit_code_name);
- if (name)
- node->v.n = jit_data(name, strlen(name) + 1, 1);
- else
- node->v.p = NULL;
- if (_jitc->note.head == NULL)
- _jitc->note.head = _jitc->note.tail = node;
- else {
- _jitc->note.tail->link = node;
- _jitc->note.tail = node;
- }
- ++_jit->note.length;
- _jitc->note.size += sizeof(jit_note_t);
- /* remember previous note is invalid due to name change */
- _jitc->note.note = NULL;
- return (_jitc->note.name = node);
-}
-
-jit_node_t *
-_jit_note(jit_state_t *_jit, const char *name, int line)
-{
- jit_node_t *node;
-
- node = jit_new_node(jit_code_note);
- if (name)
- node->v.n = jit_data(name, strlen(name) + 1, 1);
- else
- node->v.p = NULL;
- node->w.w = line;
- if (_jitc->note.head == NULL)
- _jitc->note.head = _jitc->note.tail = node;
- else {
- _jitc->note.tail->link = node;
- _jitc->note.tail = node;
- }
- if (_jitc->note.note == NULL ||
- (name == NULL && _jitc->note.note != NULL) ||
- (name != NULL && _jitc->note.note == NULL) ||
- (name != NULL && _jitc->note.note != NULL &&
- strcmp(name, (char *)_jitc->data.ptr + _jitc->note.note->v.n->u.w)))
- _jitc->note.size += sizeof(jit_line_t);
- _jitc->note.size += sizeof(jit_int32_t) * 2;
- return (_jitc->note.note = node);
-}
-
-void
-_jit_annotate(jit_state_t *_jit)
-{
- jit_node_t *node;
- jit_note_t *note;
- jit_line_t *line;
- jit_word_t length;
- jit_word_t note_offset;
- jit_word_t line_offset;
-
- /* initialize pointers in mmaped data area */
- _jit->note.ptr = (jit_note_t *)_jitc->note.base;
- _jit->note.length = 0;
-
- note = NULL;
- for (node = _jitc->note.head; node; node = node->link) {
- if (node->code == jit_code_name)
- note = new_note(node->u.p, node->v.p ? node->v.n->u.p : NULL);
- else if (node->v.p) {
- if (note == NULL)
- note = new_note(node->u.p, NULL);
- jit_set_note(note, node->v.n->u.p, node->w.w,
- (jit_uint8_t *)node->u.p - note->code);
- }
- }
- /* last note */
- if (note)
- note->size = _jit->pc.uc - note->code;
-
- /* annotations may be very complex with conditions to extend
- * or ignore redundant notes, as well as add entries to earlier
- * notes, so, relocate the information to the data buffer,
- * with likely over allocated reserved space */
-
- /* relocate jit_line_t objects */
- for (note_offset = 0; note_offset < _jit->note.length; note_offset++) {
- note = _jit->note.ptr + note_offset;
- if ((length = sizeof(jit_line_t) * note->length) == 0)
- continue;
- assert(_jitc->note.base + length < _jit->data.ptr + _jit->data.length);
- jit_memcpy(_jitc->note.base, note->lines, length);
- jit_free((jit_pointer_t *)¬e->lines);
- note->lines = (jit_line_t *)_jitc->note.base;
- _jitc->note.base += length;
- }
-
- /* relocate offset and line number information */
- for (note_offset = 0; note_offset < _jit->note.length; note_offset++) {
- note = _jit->note.ptr + note_offset;
- for (line_offset = 0; line_offset < note->length; line_offset++) {
- line = note->lines + line_offset;
- length = sizeof(jit_int32_t) * line->length;
- assert(_jitc->note.base + length <
- _jit->data.ptr + _jit->data.length);
- jit_memcpy(_jitc->note.base, line->linenos, length);
- jit_free((jit_pointer_t *)&line->linenos);
- line->linenos = (jit_int32_t *)_jitc->note.base;
- _jitc->note.base += length;
- assert(_jitc->note.base + length <
- _jit->data.ptr + _jit->data.length);
- jit_memcpy(_jitc->note.base, line->offsets, length);
- jit_free((jit_pointer_t *)&line->offsets);
- line->offsets = (jit_int32_t *)_jitc->note.base;
- _jitc->note.base += length;
- }
- }
-}
-
-void
-_jit_set_note(jit_state_t *_jit, jit_note_t *note,
- char *file, int lineno, jit_int32_t offset)
-{
- jit_line_t *line;
- jit_int32_t index;
-
- index = line_insert_index(note, offset);
- if (note->length && index == note->length &&
- note->lines[index - 1].file == file)
- --index;
- if (index >= note->length || note->lines[index].file != file)
- new_line(index, note, file, lineno, offset);
- else {
- line = note->lines + index;
- index = offset_insert_index(line, offset);
- if (index < line->length && line->offsets[index] == offset) {
- /* common case if no code was generated for several source lines */
- if (line->linenos[index] < lineno)
- line->linenos[index] = lineno;
- }
- else if (index < line->length && line->linenos[index] == lineno) {
- /* common case of extending entry */
- if (line->offsets[index] > offset)
- line->offsets[index] = offset;
- }
- else {
- /* line or offset changed */
- if ((line->length & 15) == 0) {
- jit_realloc((jit_pointer_t *)&line->linenos,
- line->length * sizeof(jit_int32_t),
- (line->length + 17) * sizeof(jit_int32_t));
- jit_realloc((jit_pointer_t *)&line->offsets,
- line->length * sizeof(jit_int32_t),
- (line->length + 17) * sizeof(jit_int32_t));
- }
- if (index < note->length) {
- jit_memmove(line->linenos + index + 1, line->linenos + index,
- sizeof(jit_int32_t) * (line->length - index));
- jit_memmove(line->offsets + index + 1, line->offsets + index,
- sizeof(jit_int32_t) * (line->length - index));
- }
- line->linenos[index] = lineno;
- line->offsets[index] = offset;
- ++line->length;
- }
- }
-}
-
-jit_bool_t
-_jit_get_note(jit_state_t *_jit, jit_pointer_t code,
- char **name, char **file, jit_int32_t *lineno)
-{
- jit_note_t *note;
- jit_line_t *line;
- jit_int32_t index;
- jit_int32_t offset;
-
- if ((index = note_search_index((jit_uint8_t *)code)) >= _jit->note.length)
- return (0);
- note = _jit->note.ptr + index;
- if ((jit_uint8_t *)code < note->code ||
- (jit_uint8_t *)code >= note->code + note->size)
- return (0);
- offset = (jit_uint8_t *)code - note->code;
- if ((index = line_search_index(note, offset)) >= note->length)
- return (0);
- if (index == 0 && offset < note->lines[0].offsets[0])
- return (0);
- line = note->lines + index;
- if ((index = offset_search_index(line, offset)) >= line->length)
- return (0);
-
- if (name)
- *name = note->name;
- if (file)
- *file = line->file;
- if (lineno)
- *lineno = line->linenos[index];
-
- return (1);
-}
-
-static jit_note_t *
-_new_note(jit_state_t *_jit, jit_uint8_t *code, char *name)
-{
- jit_note_t *note;
- jit_note_t *prev;
-
- if (_jit->note.length) {
- prev = _jit->note.ptr + _jit->note.length - 1;
- assert(code >= prev->code);
- prev->size = code - prev->code;
- }
- note = (jit_note_t *)_jitc->note.base;
- _jitc->note.base += sizeof(jit_note_t);
- ++_jit->note.length;
- note->code = code;
- note->name = name;
-
- return (note);
-}
-
-static void
-new_line(jit_int32_t index, jit_note_t *note,
- char *file, jit_int32_t lineno, jit_int32_t offset)
-{
- jit_line_t *line;
-
- if (note->lines == NULL)
- jit_alloc((jit_pointer_t *)¬e->lines, 16 * sizeof(jit_line_t));
- else if ((note->length & 15) == 15)
- jit_realloc((jit_pointer_t *)¬e->lines,
- note->length * sizeof(jit_line_t),
- (note->length + 17) * sizeof(jit_line_t));
-
- if (index < note->length)
- jit_memmove(note->lines + index + 1, note->lines + index,
- sizeof(jit_line_t) * (note->length - index));
- line = note->lines + index;
- ++note->length;
-
- line->file = file;
- line->length = 1;
- jit_alloc((jit_pointer_t *)&line->linenos, 16 * sizeof(jit_int32_t));
- line->linenos[0] = lineno;
- jit_alloc((jit_pointer_t *)&line->offsets, 16 * sizeof(jit_int32_t));
- line->offsets[0] = offset;
-}
-
-static jit_int32_t
-_note_search_index(jit_state_t *_jit, jit_uint8_t *code)
-{
- jit_int32_t bot;
- jit_int32_t top;
- jit_int32_t index;
- jit_note_t *notes;
-
- bot = 0;
- top = _jit->note.length;
- notes = _jit->note.ptr;
- for (index = (bot + top) >> 1; bot < top; index = (bot + top) >> 1) {
- if (code < notes[index].code)
- top = index;
- else if (code >= notes[index].code &&
- code - notes[index].code < notes[index].size)
- break;
- else
- bot = index + 1;
- }
-
- return (index);
-}
-
-static jit_int32_t
-line_insert_index(jit_note_t *note, jit_int32_t offset)
-{
- jit_int32_t bot;
- jit_int32_t top;
- jit_int32_t index;
- jit_line_t *lines;
-
- bot = 0;
- top = note->length;
- if ((lines = note->lines) == NULL)
- return (0);
- for (index = (bot + top) >> 1; bot < top; index = (bot + top) >> 1) {
- if (offset < *lines[index].offsets)
- top = index;
- else
- bot = index + 1;
- }
-
- return ((bot + top) >> 1);
-}
-
-static jit_int32_t
-line_search_index(jit_note_t *note, jit_int32_t offset)
-{
- jit_int32_t bot;
- jit_int32_t top;
- jit_int32_t index;
- jit_line_t *lines;
-
- bot = 0;
- top = note->length;
- if ((lines = note->lines) == NULL)
- return (0);
- for (index = (bot + top) >> 1; bot < top; index = (bot + top) >> 1) {
- if (offset < *lines[index].offsets)
- top = index;
- /* offset should be already verified to be in range */
- else if (index == note->length - 1 ||
- (offset >= *lines[index].offsets &&
- offset < *lines[index + 1].offsets))
- break;
- else
- bot = index + 1;
- }
-
- return (index);
-}
-
-static jit_int32_t
-offset_insert_index(jit_line_t *line, jit_int32_t offset)
-{
- jit_int32_t bot;
- jit_int32_t top;
- jit_int32_t index;
- jit_int32_t *offsets;
-
- bot = 0;
- top = line->length;
- offsets = line->offsets;
- for (index = (bot + top) >> 1; bot < top; index = (bot + top) >> 1) {
- if (offset < offsets[index])
- top = index;
- else
- bot = index + 1;
- }
-
- return ((bot + top) >> 1);
-}
-
-static jit_int32_t
-offset_search_index(jit_line_t *line, jit_int32_t offset)
-{
- jit_int32_t bot;
- jit_int32_t top;
- jit_int32_t index;
- jit_int32_t *offsets;
-
- bot = 0;
- top = line->length;
- offsets = line->offsets;
- for (index = (bot + top) >> 1; bot < top; index = (bot + top) >> 1) {
- if (offset < offsets[index])
- top = index;
- /* offset should be already verified to be in range */
- else if (index == line->length - 1 ||
- (offset >= offsets[index] && offset < offsets[index + 1]))
- break;
- else
- bot = index + 1;
- }
-
- return (index);
-}
diff --git a/jit/print.c b/jit/print.c
deleted file mode 100644
index d1800ba..0000000
--- a/jit/print.c
+++ /dev/null
@@ -1,367 +0,0 @@
-/*
- * Copyright (C) 2012-2018 Free Software Foundation, Inc.
- *
- * This file is part of GNU lightning.
- *
- * GNU lightning is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation; either version 3, or (at your option)
- * any later version.
- *
- * GNU lightning is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * Authors:
- * Paulo Cesar Pereira de Andrade
- */
-
-#include "jit.h"
-#include "jit/jit_private.h"
-
-#define print_chr(value) fputc(value, stdout)
-#define print_hex(value) fprintf(stdout, "0x%lx", value)
-#define print_dec(value) fprintf(stdout, "%ld", value)
-#define print_flt(value) fprintf(stdout, "%g", value)
-#define print_str(value) fprintf(stdout, "%s", value)
-#define print_ptr(value) fprintf(stdout, "%p", value)
-#define print_reg(value) \
- do { \
- if ((value) & jit_regno_patch) \
- print_chr('?'); \
- print_str(_rvs[jit_regno(value)].name); \
- } while (0)
-#define print_arg(value) \
- do { \
- print_chr('#'); \
- if (value) \
- print_dec((value)->v.w); \
- else \
- print_chr('?'); \
- } while (0)
-
-/*
- * Initialization
- */
-#include "names.c"
-
-/*
- * Implementation
- */
-void
-_jit_print(jit_state_t *_jit)
-{
- jit_node_t *node;
-
- if ((node = _jitc->head)) {
- jit_print_node(node);
- for (node = node->next; node; node = node->next) {
- print_chr('\n');
- jit_print_node(node);
- }
- print_chr('\n');
- }
-}
-
-void
-_jit_print_node(jit_state_t *_jit, jit_node_t *node)
-{
- jit_block_t *block;
- jit_int32_t value;
- jit_int32_t offset;
-
- if (node->code == jit_code_label ||
- node->code == jit_code_prolog || node->code == jit_code_epilog) {
- print_chr('L');
- print_dec(node->v.w);
- print_chr(':');
- block = _jitc->blocks.ptr + node->v.w;
- for (offset = 0; offset < _jitc->reglen; offset++) {
- if (jit_regset_tstbit(&block->reglive, offset)) {
- print_chr(' ');
- print_reg(offset);
- }
- }
- if (node->code == jit_code_prolog ||
- node->code == jit_code_epilog) {
- print_str(" /* ");
- print_str(code_name[node->code]);
- print_str(" */");
- }
- return;
- }
- value = jit_classify(node->code) &
- (jit_cc_a0_int|jit_cc_a0_flt|jit_cc_a0_dbl|jit_cc_a0_jmp|
- jit_cc_a0_reg|jit_cc_a0_rlh|jit_cc_a0_arg|
- jit_cc_a1_reg|jit_cc_a1_int|jit_cc_a1_flt|jit_cc_a1_dbl|jit_cc_a1_arg|
- jit_cc_a2_reg|jit_cc_a2_int|jit_cc_a2_flt|jit_cc_a2_dbl);
- if (!(node->flag & jit_flag_synth) && ((value & jit_cc_a0_jmp) ||
- node->code == jit_code_finishr ||
- node->code == jit_code_finishi))
- print_str(" ");
- else
- print_chr('\t');
- if (node->flag & jit_flag_synth)
- print_str(" \\__ ");
- print_str(code_name[node->code]);
- switch (node->code) {
- r:
- print_chr(' '); print_reg(node->u.w); return;
- w:
- print_chr(' '); print_hex(node->u.w); return;
- f:
- print_chr(' ');
- if (node->flag & jit_flag_data)
- print_flt(*(jit_float32_t *)node->u.n->u.w);
- else
- print_flt(node->u.f);
- return;
- d:
- print_chr(' ');
- if (node->flag & jit_flag_data)
- print_flt(*(jit_float64_t *)node->u.n->u.w);
- else
- print_flt(node->u.d);
- return;
- n:
- print_chr(' ');
- if (!(node->flag & jit_flag_node))
- print_ptr(node->u.p);
- else {
- print_chr('L');
- print_dec(node->u.n->v.w);
- }
- return;
- a:
- print_chr(' '); print_arg(node); return;
- r_r:
- print_chr(' '); print_reg(node->u.w);
- print_chr(' '); print_reg(node->v.w); return;
- r_w:
- print_chr(' '); print_reg(node->u.w);
- print_chr(' '); print_hex(node->v.w); return;
- r_f:
- print_chr(' '); print_reg(node->u.w);
- print_chr(' ');
- if (node->flag & jit_flag_data)
- print_flt(*(jit_float32_t *)node->v.n->u.w);
- else
- print_flt(node->v.f);
- return;
- r_d:
- print_chr(' '); print_reg(node->u.w);
- print_chr(' ');
- if (node->flag & jit_flag_data)
- print_flt(*(jit_float64_t *)node->v.n->u.w);
- else
- print_flt(node->v.d);
- return;
- r_a:
- print_chr(' '); print_reg(node->u.w);
- print_chr(' '); print_arg(node->v.n);
- return;
- w_r:
- print_chr(' '); print_hex(node->u.w);
- print_chr(' '); print_reg(node->v.w); return;
- w_w:
- print_chr(' '); print_hex(node->u.w);
- print_chr(' '); print_hex(node->v.w); return;
- w_a:
- print_chr(' '); print_hex(node->u.w);
- print_chr(' '); print_arg(node->v.n);
- return;
- f_a:
- print_chr(' ');
- if (node->flag & jit_flag_data)
- print_flt(*(jit_float32_t *)node->u.n->u.w);
- else
- print_flt(node->u.f);
- print_chr(' '); print_arg(node->v.n);
- return;
- d_a:
- print_chr(' ');
- if (node->flag & jit_flag_data)
- print_flt(*(jit_float64_t *)node->u.n->u.w);
- else
- print_flt(node->u.d);
- print_chr(' '); print_arg(node->v.n);
- return;
- r_r_r:
- print_chr(' '); print_reg(node->u.w);
- print_chr(' '); print_reg(node->v.w);
- print_chr(' '); print_reg(node->w.w); return;
- r_r_w:
- print_chr(' '); print_reg(node->u.w);
- print_chr(' '); print_reg(node->v.w);
- print_chr(' '); print_hex(node->w.w); return;
- q_r_r:
- print_str(" ("); print_reg(node->u.q.l);
- print_chr(' '); print_reg(node->u.q.h);
- print_str(") "); print_reg(node->v.w);
- print_chr(' '); print_reg(node->w.w); return;
- q_r_w:
- print_str(" ("); print_reg(node->u.q.l);
- print_chr(' '); print_reg(node->u.q.h);
- print_str(") "); print_reg(node->v.w);
- print_chr(' '); print_hex(node->w.w); return;
- r_r_f:
- print_chr(' '); print_reg(node->u.w);
- print_chr(' '); print_reg(node->v.w);
- print_chr(' ');
- if (node->flag & jit_flag_data)
- print_flt(*(jit_float32_t *)node->w.n->u.w);
- else
- print_flt(node->w.f);
- return;
- r_r_d:
- print_chr(' '); print_reg(node->u.w);
- print_chr(' '); print_reg(node->v.w);
- print_chr(' ');
- if (node->flag & jit_flag_data)
- print_flt(*(jit_float64_t *)node->w.n->u.w);
- else
- print_flt(node->w.d);
- return;
- w_r_r:
- print_chr(' '); print_hex(node->u.w);
- print_chr(' '); print_reg(node->v.w);
- print_chr(' '); print_reg(node->w.w); return;
- n_r_r:
- print_chr(' ');
- if (!(node->flag & jit_flag_node))
- print_ptr(node->u.p);
- else {
- print_chr('L');
- print_dec(node->u.n->v.w);
- }
- print_chr(' '); print_reg(node->v.w);
- print_chr(' '); print_reg(node->w.w); return;
- n_r_w:
- print_chr(' ');
- if (!(node->flag & jit_flag_node))
- print_ptr(node->u.p);
- else {
- print_chr('L');
- print_dec(node->u.n->v.w);
- }
- print_chr(' '); print_reg(node->v.w);
- print_chr(' '); print_hex(node->w.w); return;
- n_r_f:
- print_chr(' ');
- if (!(node->flag & jit_flag_node))
- print_ptr(node->u.p);
- else{
- print_chr('L');
- print_dec(node->u.n->v.w);
- }
- print_chr(' '); print_reg(node->v.w);
- print_chr(' ');
- if (node->flag & jit_flag_data)
- print_flt(*(jit_float32_t *)node->w.n->u.w);
- else
- print_flt(node->w.f);
- return;
- n_r_d:
- print_chr(' ');
- if (!(node->flag & jit_flag_node))
- print_ptr(node->u.p);
- else {
- print_chr('L');
- print_dec(node->u.n->v.w);
- }
- print_chr(' '); print_reg(node->v.w);
- print_chr(' ');
- if (node->flag & jit_flag_data)
- print_flt(*(jit_float64_t *)node->w.n->u.w);
- else
- print_flt(node->w.d);
- return;
- case jit_code_name:
- print_chr(' ');
- if (node->v.p && _jitc->emit)
- print_str(node->v.n->u.p);
- break;
- case jit_code_note:
- print_chr(' ');
- if (node->v.p && _jitc->emit)
- print_str(node->v.n->u.p);
- if (node->v.p && _jitc->emit && node->w.w)
- print_chr(':');
- if (node->w.w)
- print_dec(node->w.w);
- break;
- case jit_code_data:
- case jit_code_label:
- case jit_code_ellipsis:
- case jit_code_prolog: case jit_code_epilog:
- case jit_code_ret: case jit_code_prepare:
- break;
- case jit_code_save: case jit_code_load:
- goto r;
- default:
- switch (value) {
- case jit_cc_a0_reg:
- case jit_cc_a0_reg|jit_cc_a0_chg:
- case jit_cc_a0_reg|jit_cc_a0_jmp:
- goto r;
- case jit_cc_a0_int:
- goto w;
- case jit_cc_a0_flt:
- goto f;
- case jit_cc_a0_dbl:
- goto d;
- case jit_cc_a0_jmp:
- goto n;
- case jit_cc_a0_int|jit_cc_a0_arg:
- goto a;
- case jit_cc_a0_reg|jit_cc_a1_reg:
- goto r_r;
- case jit_cc_a0_reg|jit_cc_a1_int:
- goto r_w;
- case jit_cc_a0_reg|jit_cc_a1_flt:
- goto r_f;
- case jit_cc_a0_reg|jit_cc_a1_dbl:
- goto r_d;
- case jit_cc_a0_reg|jit_cc_a1_arg:
- goto r_a;
- case jit_cc_a0_int|jit_cc_a1_reg:
- goto w_r;
- case jit_cc_a0_int|jit_cc_a1_int:
- goto w_w;
- case jit_cc_a0_int|jit_cc_a1_arg:
- goto w_a;
- case jit_cc_a0_flt|jit_cc_a1_arg:
- goto f_a;
- case jit_cc_a0_dbl|jit_cc_a1_arg:
- goto d_a;
- case jit_cc_a0_reg|jit_cc_a1_reg|jit_cc_a2_reg:
- goto r_r_r;
- case jit_cc_a0_reg|jit_cc_a1_reg|jit_cc_a2_int:
- goto r_r_w;
- case jit_cc_a0_reg|jit_cc_a0_rlh|
- jit_cc_a1_reg|jit_cc_a2_reg:
- goto q_r_r;
- case jit_cc_a0_reg|jit_cc_a0_rlh|
- jit_cc_a1_reg|jit_cc_a2_int:
- goto q_r_w;
- case jit_cc_a0_reg|jit_cc_a1_reg|jit_cc_a2_flt:
- goto r_r_f;
- case jit_cc_a0_reg|jit_cc_a1_reg|jit_cc_a2_dbl:
- goto r_r_d;
- case jit_cc_a0_int|jit_cc_a1_reg|jit_cc_a2_reg:
- goto w_r_r;
- case jit_cc_a0_jmp|jit_cc_a1_reg|jit_cc_a2_reg:
- goto n_r_r;
- case jit_cc_a0_jmp|jit_cc_a1_reg|jit_cc_a2_int:
- goto n_r_w;
- case jit_cc_a0_jmp|jit_cc_a1_reg|jit_cc_a2_flt:
- goto n_r_f;
- case jit_cc_a0_jmp|jit_cc_a1_reg|jit_cc_a2_dbl:
- goto n_r_d;
- default:
- abort();
- }
- break;
- }
-}
diff --git a/jit/rewind.c b/jit/rewind.c
deleted file mode 100644
index 29f09aa..0000000
--- a/jit/rewind.c
+++ /dev/null
@@ -1,192 +0,0 @@
-/*
- * Copyright (C) 2015-2018 Free Software Foundation, Inc.
- *
- * This file is part of GNU lightning.
- *
- * GNU lightning is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation; either version 3, or (at your option)
- * any later version.
- *
- * GNU lightning is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * Authors:
- * Paulo Cesar Pereira de Andrade
- */
-
-#include "jit.h"
-#include "jit/jit_private.h"
-
-#if PROTO
-# define free_synth_list(node) _free_synth_list(_jit,node)
-static jit_node_t *_free_synth_list(jit_state_t*,jit_node_t*);
-#define rewind_prolog() _rewind_prolog(_jit)
-static void _rewind_prolog(jit_state_t*);
-#define rewind_prepare() _rewind_prepare(_jit)
-static void _rewind_prepare(jit_state_t*);
-#endif
-
-#if CODE
-/*
- * Implementation
- */
-static jit_node_t *
-_free_synth_list(jit_state_t *_jit, jit_node_t *node)
-{
- jit_node_t *next;
- next = node->next;
- free_node(node);
- for (node = next; node && (node->flag & jit_flag_synth); node = next) {
- next = node->next;
- free_node(node);
- }
- return (next);
-}
-
-static void
-_rewind_prolog(jit_state_t *_jit)
-{
- jit_node_t *node;
- jit_node_t *next;
- _jitc->function->self.size = stack_framesize;
-#if __arm__
- assert(jit_cpu.abi);
- _jitc->function->self.size += 64;
-#endif
-#if __mips__ && NEW_ABI
- /* Only add extra stack space if there are varargs
- * arguments in registers. */
- assert(jit_arg_reg_p(_jitc->function->self.argi));
- _jitc->function->self.size += 64;
-#endif
- _jitc->function->self.argi =
- _jitc->function->self.argf = _jitc->function->self.argn = 0;
- _jitc->tail = _jitc->function->prolog;
- node = _jitc->tail->next;
- _jitc->tail->next = (jit_node_t *)0;
- _jitc->tail->link = (jit_node_t *)0;
- for (; node; node = next) {
- next = node->next;
- switch (node->code) {
- case jit_code_arg:
- node->next = (jit_node_t *)0;
- jit_make_arg(node);
- break;
- case jit_code_arg_f:
- node->next = (jit_node_t *)0;
- jit_make_arg_f(node);
- break;
- case jit_code_arg_d:
- node->next = (jit_node_t *)0;
- jit_make_arg_d(node);
- break;
- case jit_code_getarg_c:
- jit_getarg_c(node->u.w, node->v.n);
- next = free_synth_list(node);
- break;
- case jit_code_getarg_uc:
- jit_getarg_uc(node->u.w, node->v.n);
- next = free_synth_list(node);
- break;
- case jit_code_getarg_s:
- jit_getarg_s(node->u.w, node->v.n);
- next = free_synth_list(node);
- break;
- case jit_code_getarg_us:
- jit_getarg_us(node->u.w, node->v.n);
- next = free_synth_list(node);
- break;
- case jit_code_getarg_i:
- jit_getarg_i(node->u.w, node->v.n);
- next = free_synth_list(node);
- break;
- case jit_code_getarg_f:
- jit_getarg_f(node->u.w, node->v.n);
- next = free_synth_list(node);
- break;
- case jit_code_getarg_d:
- jit_getarg_d(node->u.w, node->v.n);
- next = free_synth_list(node);
- break;
- case jit_code_putargr:
- jit_putargr(node->u.w, node->v.n);
- next = free_synth_list(node);
- break;
- case jit_code_putargi:
- jit_putargi(node->u.w, node->v.n);
- next = free_synth_list(node);
- break;
- case jit_code_putargr_f:
- jit_putargr_f(node->u.w, node->v.n);
- next = free_synth_list(node);
- break;
- case jit_code_putargi_f:
- jit_putargi_f(node->u.f, node->v.n);
- next = free_synth_list(node);
- break;
- case jit_code_putargr_d:
- jit_putargr_d(node->u.w, node->v.n);
- next = free_synth_list(node);
- break;
- case jit_code_putargi_d:
- jit_putargi_d(node->u.d, node->v.n);
- next = free_synth_list(node);
- break;
- default:
- node->next = (jit_node_t *)0;
- link_node(node);
- break;
- }
- }
-}
-
-static void
-_rewind_prepare(jit_state_t *_jit)
-{
- jit_node_t *node;
- jit_node_t *next;
- _jitc->function->call.argi =
- _jitc->function->call.argf =
- _jitc->function->call.size = 0;
- _jitc->tail = _jitc->prepare;
- node = _jitc->tail->next;
- _jitc->tail->next = (jit_node_t *)0;
- _jitc->tail->link = (jit_node_t *)0;
- for (; node; node = next) {
- next = node->next;
- switch (node->code) {
- case jit_code_pushargr:
- jit_pushargr(node->u.w);
- next = free_synth_list(node);
- break;
- case jit_code_pushargi:
- jit_pushargi(node->u.w);
- next = free_synth_list(node);
- break;
- case jit_code_pushargr_f:
- jit_pushargr_f(node->u.w);
- next = free_synth_list(node);
- break;
- case jit_code_pushargi_f:
- jit_pushargi_f(node->u.f);
- next = free_synth_list(node);
- break;
- case jit_code_pushargr_d:
- jit_pushargr_d(node->u.w);
- next = free_synth_list(node);
- break;
- case jit_code_pushargi_d:
- jit_pushargi_d(node->u.d);
- next = free_synth_list(node);
- break;
- default:
- node->next = (jit_node_t *)0;
- link_node(node);
- break;
- }
- }
-}
-#endif
diff --git a/jit/size.c b/jit/size.c
deleted file mode 100644
index 5a7f291..0000000
--- a/jit/size.c
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
- * Copyright (C) 2013-2018 Free Software Foundation, Inc.
- *
- * This file is part of GNU lightning.
- *
- * GNU lightning is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation; either version 3, or (at your option)
- * any later version.
- *
- * GNU lightning is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * Authors:
- * Paulo Cesar Pereira de Andrade
- */
-
-#include "jit.h"
-#include "jit/jit_private.h"
-#if GET_JIT_SIZE
-# include <stdio.h>
-#endif
-
-/*
- * Initialization
- */
-static jit_int16_t _szs[jit_code_last_code] = {
-#if GET_JIT_SIZE
-# define JIT_INSTR_MAX 256
-#else
-# if defined(__i386__) || defined(__x86_64__)
-# include "x86-sz.c"
-# elif defined(__mips__)
-# include "mips-sz.c"
-# elif defined(__arm__)
-# include "arm-sz.c"
-# elif defined(__ppc__) || defined(__powerpc__)
-# include "ppc-sz.c"
-# elif defined(__sparc__)
-# include "sparc-sz.c"
-# elif defined(__ia64__)
-# include "ia64-sz.c"
-# elif defined(__hppa__)
-# include "hppa-sz.c"
-# elif defined(__aarch64__)
-# include "aarch64-sz.c"
-# elif defined(__s390__) || defined(__s390x__)
-# include "s390-sz.c"
-# elif defined(__alpha__)
-# include "alpha-sz.c"
-# endif
-#endif
-};
-
-/*
- * Implementation
- */
-void
-jit_init_size(void)
-{
-#if DEBUG
-# if !GET_JIT_SIZE
- jit_word_t offset;
-
- for (offset = 0; offset < jit_size(_szs); offset++)
- if (_szs[offset] != 0)
- return;
- /* Ensure data was collected */
- abort();
-# endif
-#endif
-}
-
-#if GET_JIT_SIZE
-void
-_jit_size_prepare(jit_state_t *_jit)
-{
- _jitc->cptr = _jit->code.ptr;
- _jitc->size = _jit->pc.w;
-}
-
-void
-_jit_size_collect(jit_state_t *_jit, jit_node_t *node)
-{
- jit_word_t length;
-
- if (_jitc->cptr == _jit->code.ptr) {
- length = _jit->pc.w - _jitc->size;
- if (_szs[node->code] < length)
- _szs[node->code] = length;
- }
-}
-
-#else
-jit_word_t
-_jit_get_size(jit_state_t *_jit)
-{
- jit_word_t size;
- jit_node_t *node;
-
- for (size = JIT_INSTR_MAX, node = _jitc->head; node; node = node->next)
- size += _szs[node->code];
-
- return ((size + 4095) & -4096);
-}
-#endif
-
-jit_word_t
-jit_get_max_instr(void)
-{
- return (JIT_INSTR_MAX >= 144 ? JIT_INSTR_MAX : 144);
-}
-
-void
-jit_finish_size(void)
-{
-#if GET_JIT_SIZE
- FILE *fp;
- jit_word_t offset;
-
- /* Define a single path */
- fp = fopen(JIT_SIZE_PATH, "a");
- assert(fp);
- for (offset = 0; offset < jit_size(_szs); offset++)
- fprintf(fp, "%d %d\n", offset, _szs[offset]);
- fclose(fp);
-#endif
-}
- [Guile-commits] 37/86: Tests for some div operations, (continued)
- [Guile-commits] 37/86: Tests for some div operations, Andy Wingo, 2019/04/03
- [Guile-commits] 35/86: Add new tests, Andy Wingo, 2019/04/03
- [Guile-commits] 28/86: Beginnings of port of x86 to new design, Andy Wingo, 2019/04/03
- [Guile-commits] 44/86: Add mov_addr test, Andy Wingo, 2019/04/03
- [Guile-commits] 38/86: Add more div tests, Andy Wingo, 2019/04/03
- [Guile-commits] 52/86: Add sti tests, Andy Wingo, 2019/04/03
- [Guile-commits] 47/86: Add ldr tests, Andy Wingo, 2019/04/03
- [Guile-commits] 46/86: Add bswap tests, and fix missing breaks in jit_load_args, Andy Wingo, 2019/04/03
- [Guile-commits] 50/86: Add ldxi tests, Andy Wingo, 2019/04/03
- [Guile-commits] 41/86: Add lsh/rsh tests, Andy Wingo, 2019/04/03
- [Guile-commits] 15/86: Remove unneeded bits of lightning,
Andy Wingo <=
- [Guile-commits] 45/86: Add extr tests, Andy Wingo, 2019/04/03
- [Guile-commits] 42/86: Add comr/negr tests, Andy Wingo, 2019/04/03
- [Guile-commits] 55/86: Add .gitlab-ci.yml, Andy Wingo, 2019/04/03
- [Guile-commits] 43/86: Rework naming of test suite files, Andy Wingo, 2019/04/03
- [Guile-commits] 48/86: Add ldi tests, Andy Wingo, 2019/04/03
- [Guile-commits] 57/86: Fix stxi_d bug, Andy Wingo, 2019/04/03
- [Guile-commits] 49/86: Add ldxr tests, Andy Wingo, 2019/04/03
- [Guile-commits] 61/86: Add int/int reg/imm compare-and-branch tests, Andy Wingo, 2019/04/03
- [Guile-commits] 63/86: Add unordered float compare-and-branch tests, Andy Wingo, 2019/04/03
- [Guile-commits] 53/86: Add stxr tests, Andy Wingo, 2019/04/03