cmucl-cvs

cmucl-cvs@common-lisp.net

2904 discussions

[Git][cmucl/cmucl][issue-97-define-ud2-inst] Fix disassembly of break inst
by Raymond Toy 20 Mar '21

20 Mar '21

Raymond Toy pushed to branch issue-97-define-ud2-inst at cmucl / cmucl Commits: 73e864e8 by Raymond Toy at 2021-03-20T09:09:29-07:00 Fix disassembly of break inst The code field for the break instruction had the wrong byte position. It was (byte 8 8), but it should be (byte 8 16). `(disassemble 'lisp::halt)` works now. - - - - - 1 changed file: - src/compiler/x86/insts.lisp Changes: ===================================== src/compiler/x86/insts.lisp ===================================== @@ -2064,7 +2064,7 @@ (disassem:define-instruction-format (break 24 :default-printer '(:name :tab code)) (op :fields (list (byte 8 0) (byte 8 8)) :value '(#xb00001111 #b00001011)) - (code :field (byte 8 8))) + (code :field (byte 8 16))) (define-emitter emit-break-inst 24 (byte 8 0) (byte 8 8) (byte 8 16)) View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/commit/73e864e8ddcef408af202f9… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/commit/73e864e8ddcef408af202f9… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl] Pushed new branch issue-97-define-ud2-inst
by Raymond Toy 20 Mar '21

20 Mar '21

Raymond Toy pushed new branch issue-97-define-ud2-inst at cmucl / cmucl -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/tree/issue-97-define-ud2-inst You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl][native-image] 4 commits: Make all labels global and assign a section name.
by Raymond Toy 14 Feb '21

14 Feb '21

Raymond Toy pushed to branch native-image at cmucl / cmucl Commits: 62f09401 by Raymond Toy at 2021-02-14T10:07:00-08:00 Make all labels global and assign a section name. Every label is now a global symbol. Prepend each output file with a .section to name the section we're creating. - - - - - 916ccc3a by Raymond Toy at 2021-02-14T11:47:16-08:00 Emit addresses of assembler routines to internals.h Create an array that contains the addresses of all the lisp assembler routines so that when writing out the assembly code, we can create symbols for the lisp assembler routines. - - - - - c6791370 by Raymond Toy at 2021-02-14T11:59:02-08:00 Dump the lisp assembly routines. For now, we just write out .equ pseudo op for the address of each lisp assembler routine so that the linker doesn't have any unresolved values. This is a workaround for now. Ideally, these would be real relocatable symbols at the right address in the read-only space so that everything can be relocated. - - - - - 9f3243f4 by Raymond Toy at 2021-02-14T12:39:18-08:00 Print out the initial function addr for reference. - - - - - 2 changed files: - src/compiler/generic/new-genesis.lisp - src/lisp/save.c Changes: ===================================== src/compiler/generic/new-genesis.lisp ===================================== @@ -2448,7 +2448,7 @@ (and (>= (length string) (length head)) (string= string head :end1 (length head)))) -(defun emit-c-header-aux () +(defun emit-c-header-aux (assembler-routines) (format t "/*~% * Machine generated header file. Do not edit.~% */~2%") (format t "#ifndef _INTERNALS_H_~%#define _INTERNALS_H_~2%") ;; Write out various constants @@ -2602,6 +2602,17 @@ (remove-if #'(lambda (char) (member char '(#\% #\* #\.))) (symbol-name feature)))))) + + (format t "~2%#if defined(DEFINE_ASM)~%") + (format t "/* Assembly routines */~%") + (format t "unsigned long lisp_asm_routines[] = {~%") + (dolist (routine (sort (copy-list *cold-assembler-routines*) + #'< :key #'cdr)) + (format t " 0x~8,'0x, /* ~S */~%" + (cdr routine) (car routine))) + (format t " 0x~8,'0x, /* End marker */~%" 0) + (format t "};~%") + (format t "#endif~%") ;; (format t "~%#endif~%")) @@ -2622,14 +2633,14 @@ (string/= line1 line2)) (return t))))))) -(defun emit-c-header (name) +(defun emit-c-header (name assembler-routines) (let* ((new-name (concatenate 'string (namestring name) ".NEW")) (unix-newname (unix-namestring new-name nil))) (with-open-file (*standard-output* new-name :direction :output :if-exists :supersede) - (emit-c-header-aux)) + (emit-c-header-aux assembler-routines)) (cond ((not (probe-file name)) (unix:unix-chmod unix-newname #o444) (rename-file new-name name) @@ -2755,13 +2766,15 @@ :if-exists :supersede) (write-map-file))) (when header-name + (format t "cold-assembler ~S~%" *cold-assembler-routines*) (emit-c-header (merge-pathnames (if (eq header-name t) "internals.h" (merge-pathnames header-name (make-pathname :type "h"))) - core-name)) + core-name) + *cold-assembler-routines*) (emit-makefile-header (merge-pathnames (if (eq header-name t) "internals.inc" ===================================== src/lisp/save.c ===================================== @@ -13,6 +13,8 @@ #include <limits.h> #include <math.h> +/* Get the lisp assembly routines because we need them */ +#define DEFINE_ASM #include "lisp.h" #include "os.h" #include "internals.h" @@ -394,6 +396,8 @@ save_executable(char *filename, lispobj init_function) fflush(stdout); printf("Linking executable...\n"); + printf(" init_function 0x%08lx\n", init_function); + fflush(stdout); rc = obj_run_linker(init_function, filename); printf("done.\n"); @@ -415,7 +419,8 @@ static char* asmtab_types[256]; void asm_label(lispobj* ptr, lispobj object, FILE* f) { - fprintf(f, "L%lx:\n", (unsigned long) ptr); + fprintf(f, "\t.global\tL%08lx\n", (unsigned long) ptr); + fprintf(f, "L%08lx:\n", (unsigned long) ptr); } void @@ -1356,6 +1361,7 @@ write_asm_object(const char *dir, int id, os_vm_address_t start, os_vm_address_t { char asm_file[PATH_MAX]; FILE* f; + int k; printf("write_asm_object space %d start %p end %p\n", id, start, end); @@ -1365,14 +1371,25 @@ write_asm_object(const char *dir, int id, os_vm_address_t start, os_vm_address_t lispobj* ptr = (lispobj*) start; lispobj* end_ptr = (lispobj*) end; + + /* Set the section name */ + fprintf(f, "\t.section\t\"space%d\", \"wx\"\n", id); + /* Print the assembly routines */ + k = 0; + while (lisp_asm_routines[k] != 0) { + fprintf(f, "\t.set\tL%08lx, 0x%08lx\n", + lisp_asm_routines[k], + lisp_asm_routines[k]); + ++k; + } + /* * If the id is the static space, we need special handling for * beginning which has NIL in a funny way to make NIL a symbol and * list. */ if (id == STATIC_SPACE_ID) { - int k; /* Output the first word */ asm_header_word(ptr, *ptr, f, NULL); View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/6072cf3f9f6d5431f24153… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/6072cf3f9f6d5431f24153… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl][native-image] 5 commits: Fix #103: Remove random-mt19937-update
by Raymond Toy 14 Feb '21

14 Feb '21

Raymond Toy pushed to branch native-image at cmucl / cmucl Commits: b6a38aa0 by Raymond Toy at 2021-02-13T09:56:15-08:00 Fix #103: Remove random-mt19937-update We don't use the MT19937 RNG anymore, so we can remove this assembly routine. But since the code still exists for mt19937, just use reader-conditionals to disable this. - - - - - 9b1abca5 by Raymond Toy at 2021-02-13T18:20:36+00:00 Merge branch 'issue-103-remove-random-mt19937-update' into 'master' Fix #103: Remove random-mt19937-update Closes #103 See merge request cmucl/cmucl!71 - - - - - 6c4e032d by Raymond Toy at 2021-02-13T15:06:43-08:00 Merge branch 'master' into native-image - - - - - b2d56ebe by Raymond Toy at 2021-02-13T17:24:09-08:00 Add conditionalization in to match gencgc.c - - - - - 6072cf3f by Raymond Toy at 2021-02-13T17:35:39-08:00 Still print out a note for asm_header_word. Replace all calls of asm_header_word with a note of "" with a note of NULL, which means nothing to print in the comment. - - - - - 2 changed files: - src/assembly/x86/arith.lisp - src/lisp/save.c Changes: ===================================== src/assembly/x86/arith.lisp ===================================== @@ -313,7 +313,7 @@ ;;; the state vector with new random numbers. The state vector is ;;; passed in the EAX register. ;;; -#+assembler ; we don't want a vop for this one. +#+(and random-mt19937 assembler) ; we don't want a vop for this one. (define-assembly-routine (random-mt19937-update) ((:temp state unsigned-reg eax-offset) ===================================== src/lisp/save.c ===================================== @@ -462,7 +462,12 @@ asm_header_word(lispobj* ptr, lispobj object, FILE* f, const char* note) unsigned long len = HeaderValue(object); unsigned long type = TypeOf(object); - fprintf(f, "\t.4byte\t0x%lx << 8 + %ld\t# %s\n", len, type, asmtab_types[type]); + fprintf(f, "\t.4byte\t0x%lx << 8 + %ld\t# %s", len, type, asmtab_types[type]); + if (note) { + fprintf(f, ": %s\n", note); + } else { + fprintf(f, "\n"); + } } @@ -487,7 +492,7 @@ asm_boxed(lispobj* ptr, lispobj object, FILE* f) asm_label(ptr, object, f); - asm_header_word(ptr, object, f, ""); + asm_header_word(ptr, object, f, NULL); for (k = 1; k < len; ++k) { asm_lispobj(ptr + k, ptr[k], f); @@ -542,7 +547,7 @@ asm_fdefn(lispobj* ptr, lispobj object, FILE* f) { asm_label(ptr, object, f); - asm_header_word(ptr, object, f, "fdefn"); + asm_header_word(ptr, object, f, NULL); asm_lispobj(ptr + 1, ptr[1], f); asm_lispobj(ptr + 2, ptr[2], f); @@ -576,7 +581,7 @@ asm_simple_vector(lispobj* ptr, lispobj object, FILE* f) lispobj* data = ptr + 2; asm_label(ptr, object, f); - asm_header_word(ptr, object, f, "simple vector"); + asm_header_word(ptr, object, f, NULL); asm_lispobj(ptr + 1, ptr[1], f); for (k = 0; k < len; ++k) { @@ -596,7 +601,7 @@ asm_closure_header(lispobj* ptr, lispobj object, FILE* f) closure = (struct closure *) ptr; asm_label(ptr, object, f); - asm_header_word(ptr, object, f, "closure header"); + asm_header_word(ptr, object, f, NULL); fprintf(f, "\t.4byte\tL%08lx\n", closure->function); nwords -= 2; @@ -614,7 +619,7 @@ asm_symbol_header(lispobj* ptr, lispobj object, FILE* f) struct symbol* sym = (struct symbol*) ptr; asm_label(ptr, object, f); - asm_header_word(ptr, object, f, "symbol header"); + asm_header_word(ptr, object, f, NULL); asm_lispobj(&sym->value, sym->value, f); asm_lispobj(&sym->hash, sym->hash, f); asm_lispobj(&sym->plist, sym->plist, f); @@ -653,7 +658,7 @@ asm_code_header(lispobj* ptr, lispobj object, FILE* f) #endif asm_label(ptr, object, f); - asm_header_word(ptr, object, f, "code header"); + asm_header_word(ptr, object, f, NULL); for (k = 0; k < nheader_words - 1; ++k) { asm_lispobj(ptr + k + 1, ptr[k + 1], f); @@ -677,7 +682,7 @@ asm_code_header(lispobj* ptr, lispobj object, FILE* f) fprintf(f, "# ->code %p\n", &fheaderp->code); #endif asm_label((lispobj*)fheaderp, *((lispobj*)fheaderp), f); - asm_header_word(&fheaderp->header, fheaderp->header, f, "function header"); + asm_header_word(&fheaderp->header, fheaderp->header, f, NULL); fprintf(f, "\t.4byte\tL%lx\n", fheaderp->self); asm_lispobj(&fheaderp->next, fheaderp->next, f); asm_lispobj(&fheaderp->name, fheaderp->name, f); @@ -764,7 +769,7 @@ asm_simple_string(lispobj* where, lispobj object, FILE* f) #endif asm_label(where, object, f); - asm_header_word(where, object, f, "simple string"); + asm_header_word(where, object, f, NULL); asm_lispobj(where + 1, where[1], f); s = (uint16_t*) vector->data; @@ -802,7 +807,7 @@ asm_vector_bit(lispobj* ptr, lispobj object, FILE* f) #endif asm_label(ptr, object, f); - asm_header_word(ptr, object, f, "simple bit-vector"); + asm_header_word(ptr, object, f, NULL); asm_lispobj(ptr + 1, ptr[1], f); data = vector->data; @@ -851,7 +856,7 @@ asm_single_float(lispobj* ptr, lispobj object, FILE* f) struct single_float* obj = (struct single_float*) ptr; asm_label(ptr, object, f); - asm_header_word(ptr, object, f, "single float"); + asm_header_word(ptr, object, f, NULL); print_float(f, obj->value); return 2; @@ -895,7 +900,7 @@ asm_double_float(lispobj* ptr, lispobj object, FILE* f) struct double_float* obj = (struct double_float*) ptr; asm_label(ptr, object, f); - asm_header_word(ptr, object, f, "double float"); + asm_header_word(ptr, object, f, NULL); asm_lispobj(&obj->filler, obj->filler, f); print_double(f, obj->value); @@ -908,7 +913,7 @@ asm_double_double_float(lispobj* ptr, lispobj object, FILE* f) struct double_double_float* obj = (struct double_double_float*) ptr; asm_label(ptr, object, f); - asm_header_word(ptr, object, f, "double double float"); + asm_header_word(ptr, object, f, NULL); asm_lispobj(&obj->filler, obj->filler, f); print_double(f, obj->hi); @@ -923,7 +928,7 @@ asm_complex_single_float(lispobj* ptr, lispobj object, FILE* f) struct complex_single_float* obj = (struct complex_single_float*) ptr; asm_label(ptr, object, f); - asm_header_word(ptr, object, f, "complex single-float"); + asm_header_word(ptr, object, f, NULL); print_float(f, obj->real); print_float(f, obj->imag); /* Force double word boundary */ @@ -938,7 +943,7 @@ asm_complex_double_float(lispobj* ptr, lispobj object, FILE* f) struct complex_double_float* obj = (struct complex_double_float*) ptr; asm_label(ptr, object, f); - asm_header_word(ptr, object, f, "complex double-float"); + asm_header_word(ptr, object, f, NULL); asm_lispobj(&obj->filler, obj->filler, f); print_double(f, obj->real); @@ -953,7 +958,7 @@ asm_complex_double_double_float(lispobj* ptr, lispobj object, FILE* f) struct complex_double_double_float* obj = (struct complex_double_double_float*) ptr; asm_label(ptr, object, f); - asm_header_word(ptr, object, f, "complex double-float"); + asm_header_word(ptr, object, f, NULL); asm_lispobj(&obj->filler, obj->filler, f); print_double(f, obj->real_hi); @@ -981,7 +986,7 @@ asm_vector_unsigned_byte_2(lispobj* ptr, lispobj object, FILE* f) nwords = CEILING(NWORDS(length, 16) + 2, 2); #endif asm_label(ptr, object, f); - asm_header_word(ptr, object, f, "vector unsigned_byte 2"); + asm_header_word(ptr, object, f, NULL); asm_lispobj(ptr + 1, ptr[1], f); data = vector->data; @@ -1012,7 +1017,7 @@ asm_vector_unsigned_byte_4(lispobj* ptr, lispobj object, FILE* f) nwords = CEILING(NWORDS(length, 8) + 2, 2); #endif asm_label(ptr, object, f); - asm_header_word(ptr, object, f, "vector unsigned_byte 4"); + asm_header_word(ptr, object, f, NULL); asm_lispobj(ptr + 1, ptr[1], f); data = vector->data; @@ -1043,7 +1048,7 @@ asm_vector_unsigned_byte_8(lispobj* ptr, lispobj object, FILE* f) nwords = CEILING(NWORDS(length, 4) + 2, 2); #endif asm_label(ptr, object, f); - asm_header_word(ptr, object, f, "vector unsigned_byte 8"); + asm_header_word(ptr, object, f, NULL); asm_lispobj(ptr + 1, ptr[1], f); data = vector->data; @@ -1072,7 +1077,7 @@ asm_vector_unsigned_byte_16(lispobj* ptr, lispobj object, FILE* f) nwords = CEILING(NWORDS(length, 2) + 2, 2); #endif asm_label(ptr, object, f); - asm_header_word(ptr, object, f, "vector unsigned_byte 16"); + asm_header_word(ptr, object, f, NULL); asm_lispobj(ptr + 1, ptr[1], f); data = (uint16_t*) vector->data; @@ -1104,7 +1109,7 @@ asm_vector_unsigned_byte_32(lispobj* ptr, lispobj object, FILE* f) #endif asm_label(ptr, object, f); - asm_header_word(ptr, object, f, "vector unsigned_byte 32"); + asm_header_word(ptr, object, f, NULL); asm_lispobj(ptr + 1, ptr[1], f); data = vector->data; @@ -1134,7 +1139,7 @@ asm_vector_double_float(lispobj* ptr, lispobj object, FILE* f) #endif asm_label(ptr, object, f); - asm_header_word(ptr, object, f, "vector double-float"); + asm_header_word(ptr, object, f, NULL); asm_lispobj(ptr + 1, ptr[1], f); data = (const double*) vector->data; @@ -1160,7 +1165,7 @@ asm_vector_double_double_float(lispobj* ptr, lispobj object, FILE* f) nwords = CEILING(length * 4 + 2, 2); asm_label(ptr, object, f); - asm_header_word(ptr, object, f, "vector double-float"); + asm_header_word(ptr, object, f, NULL); asm_lispobj(ptr + 1, ptr[1], f); data = (const double*) vector->data; @@ -1181,7 +1186,7 @@ asm_bignum(lispobj* ptr, lispobj object, FILE* f) len = CEILING(len, 2); asm_label(ptr, object, f); - asm_header_word(ptr, object, f, "bignum"); + asm_header_word(ptr, object, f, NULL); for (k = 1; k < len; ++k) { fprintf(f, "\t.4byte\t0x%lx\t# %lu\n", ptr[k], ptr[k]); @@ -1194,7 +1199,7 @@ int asm_sap(lispobj* ptr, lispobj object, FILE* f) { asm_label(ptr, object, f); - asm_header_word(ptr, object, f, "sap"); + asm_header_word(ptr, object, f, NULL); /* Just print out the raw value of the address */ fprintf(f, "\t.4byte\t0x%lx\n", ptr[1]); @@ -1215,11 +1220,19 @@ init_asmtab(void) asmtab_types[type_Ratio] = "Ratio"; asmtab_types[type_SingleFloat] = "SingleFloat"; asmtab_types[type_DoubleFloat] = "DoubleFloat"; +#ifdef type_DoubleDoubleFloat asmtab_types[type_DoubleDoubleFloat] = "DoubleDoubleFloat"; +#endif asmtab_types[type_Complex] = "Complex"; +#ifdef type_ComplexSingleFloat asmtab_types[type_ComplexSingleFloat] = "ComplexSingleFloat"; +#endif +#ifdef type_ComplexDoubleFloat asmtab_types[type_ComplexDoubleFloat] = "ComplexDoubleFloat"; +#endif +#ifdef type_ComplexDoubleDoubleFloat asmtab_types[type_ComplexDoubleDoubleFloat] = "ComplexDoubleDoubleFloat"; +#endif asmtab_types[type_SimpleArray] = "SimpleArray"; asmtab_types[type_SimpleString] = "SimpleString"; asmtab_types[type_SimpleBitVector] = "SimpleBitVector"; @@ -1229,16 +1242,32 @@ init_asmtab(void) asmtab_types[type_SimpleArrayUnsignedByte8] = "SimpleArrayUnsignedByte8"; asmtab_types[type_SimpleArrayUnsignedByte16] = "SimpleArrayUnsignedByte16"; asmtab_types[type_SimpleArrayUnsignedByte32] = "SimpleArrayUnsignedByte32"; +#ifdef type_SimpleArraySignedByte8 asmtab_types[type_SimpleArraySignedByte8] = "SimpleArraySignedByte8"; +#endif +#ifdef type_SimpleArraySignedByte16 asmtab_types[type_SimpleArraySignedByte16] = "SimpleArraySignedByte16"; +#endif +#ifdef type_SimpleArraySignedByte30 asmtab_types[type_SimpleArraySignedByte30] = "SimpleArraySignedByte30"; +#endif +#ifdef type_SimpleArraySignedByte32 asmtab_types[type_SimpleArraySignedByte32] = "SimpleArraySignedByte32"; +#endif asmtab_types[type_SimpleArraySingleFloat] = "SimpleArraySingleFloat"; asmtab_types[type_SimpleArrayDoubleFloat] = "SimpleArrayDoubleFloat"; +#ifdef type_SimpleArrayDoubleDoubleFloat asmtab_types[type_SimpleArrayDoubleDoubleFloat] = "SimpleArrayDoubleDoubleFloat"; +#endif +#ifdef type_SimpleArrayComplexSingleFloat asmtab_types[type_SimpleArrayComplexSingleFloat] = "SimpleArrayComplexSingleFloat"; +#endif +#ifdef type_SimpleArrayComplexDoubleFloat asmtab_types[type_SimpleArrayComplexDoubleFloat] = "SimpleArrayComplexDoubleFloat"; +#endif +#ifdef type_SimpleArrayComplexDoubleDoubleFloat asmtab_types[type_SimpleArrayComplexDoubleDoubleFloat] = "SimpleArrayComplexDoubleDoubleFloat"; +#endif asmtab_types[type_ComplexString] = "ComplexString"; asmtab_types[type_ComplexBitVector] = "ComplexBitVector"; asmtab_types[type_ComplexVector] = "ComplexVector"; @@ -1280,11 +1309,19 @@ init_asmtab(void) asmtab[type_Ratio] = asm_boxed; asmtab[type_SingleFloat] = asm_single_float; asmtab[type_DoubleFloat] = asm_double_float; +#ifdef type_DoubleDoubleFloat asmtab[type_DoubleDoubleFloat] = asm_double_double_float; +#endif asmtab[type_Complex] = asm_boxed; +#ifdef type_ComplexSingleFloat asmtab[type_ComplexSingleFloat] = asm_complex_single_float; +#endif +#ifdef type_ComplexDoubleFloat asmtab[type_ComplexDoubleFloat] = asm_complex_double_float; +#endif +#ifdef type_ComplexDoubleDoubleFloat asmtab[type_ComplexDoubleDoubleFloat] = asm_complex_double_double_float; +#endif asmtab[type_SimpleArray] = asm_boxed; asmtab[type_SimpleString] = asm_simple_string; asmtab[type_SimpleBitVector] = asm_vector_bit; @@ -1295,12 +1332,16 @@ init_asmtab(void) asmtab[type_SimpleArrayUnsignedByte16] = asm_vector_unsigned_byte_16; asmtab[type_SimpleArrayUnsignedByte32] = asm_vector_unsigned_byte_32; asmtab[type_SimpleArrayDoubleFloat] = asm_vector_double_float; +#ifdef type_SimpleArrayDoubleDoubleFloat asmtab[type_SimpleArrayDoubleDoubleFloat] = asm_vector_double_double_float; +#endif asmtab[type_ComplexString] = asm_boxed; asmtab[type_ComplexVector] = asm_boxed; asmtab[type_CodeHeader] = asm_code_header; +#if defined(i386) || defined(__x86_64) asmtab[type_ClosureHeader] = asm_closure_header; asmtab[type_FuncallableInstanceHeader] = asm_closure_header; +#endif /* Just use asm_boxed or have a special version for a value cell? */ asmtab[type_ValueCellHeader] = asm_boxed; asmtab[type_SymbolHeader] = asm_symbol_header; @@ -1334,7 +1375,7 @@ write_asm_object(const char *dir, int id, os_vm_address_t start, os_vm_address_t int k; /* Output the first word */ - asm_header_word(ptr, *ptr, f, ""); + asm_header_word(ptr, *ptr, f, NULL); /* Header word for NIL */ asm_header_word(ptr + 1, ptr[1], f, "NIL header"); /* Label for NIL */ View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/2f2f9ba8db53aac8b2ce05… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/2f2f9ba8db53aac8b2ce05… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl][master] 2 commits: Fix #103: Remove random-mt19937-update
by Raymond Toy 13 Feb '21

13 Feb '21

Raymond Toy pushed to branch master at cmucl / cmucl Commits: b6a38aa0 by Raymond Toy at 2021-02-13T09:56:15-08:00 Fix #103: Remove random-mt19937-update We don't use the MT19937 RNG anymore, so we can remove this assembly routine. But since the code still exists for mt19937, just use reader-conditionals to disable this. - - - - - 9b1abca5 by Raymond Toy at 2021-02-13T18:20:36+00:00 Merge branch 'issue-103-remove-random-mt19937-update' into 'master' Fix #103: Remove random-mt19937-update Closes #103 See merge request cmucl/cmucl!71 - - - - - 1 changed file: - src/assembly/x86/arith.lisp Changes: ===================================== src/assembly/x86/arith.lisp ===================================== @@ -313,7 +313,7 @@ ;;; the state vector with new random numbers. The state vector is ;;; passed in the EAX register. ;;; -#+assembler ; we don't want a vop for this one. +#+(and random-mt19937 assembler) ; we don't want a vop for this one. (define-assembly-routine (random-mt19937-update) ((:temp state unsigned-reg eax-offset) View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/f99321c7080b723a0d0f4f… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/f99321c7080b723a0d0f4f… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl] Pushed new branch issue-103-remove-random-mt19937-update
by Raymond Toy 13 Feb '21

13 Feb '21

Raymond Toy pushed new branch issue-103-remove-random-mt19937-update at cmucl / cmucl -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/tree/issue-103-remove-random-m… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl][native-image] Fix asm_closure_header and add table to print out header types
by Raymond Toy 12 Feb '21

12 Feb '21

Raymond Toy pushed to branch native-image at cmucl / cmucl Commits: 2f2f9ba8 by Raymond Toy at 2021-02-10T17:26:13-08:00 Fix asm_closure_header and add table to print out header types Instead of just dumping a closure header as a boxed structure, need to be more careful to handle the closure function correctly. Also added asmtab_types array to map the header type to the name of the header. This is mostly for making reading the assembly easier so we have a name for each header type instead of memorizing the header type value. - - - - - 1 changed file: - src/lisp/save.c Changes: ===================================== src/lisp/save.c ===================================== @@ -409,6 +409,8 @@ save_executable(char *filename, lispobj init_function) * handle the type value when printing out the assembly code. */ static int (*asmtab[256])(lispobj* where, lispobj object, FILE* f); +static char* asmtab_types[256]; + void asm_label(lispobj* ptr, lispobj object, FILE* f) @@ -460,7 +462,7 @@ asm_header_word(lispobj* ptr, lispobj object, FILE* f, const char* note) unsigned long len = HeaderValue(object); unsigned long type = TypeOf(object); - fprintf(f, "\t.4byte\t0x%lx << 8 + %ld\t# %s\n", len, type, note); + fprintf(f, "\t.4byte\t0x%lx << 8 + %ld\t# %s\n", len, type, asmtab_types[type]); } @@ -587,7 +589,23 @@ asm_simple_vector(lispobj* ptr, lispobj object, FILE* f) int asm_closure_header(lispobj* ptr, lispobj object, FILE* f) { - return asm_boxed(ptr, object, f); + struct closure *closure; + int k; + int nwords = CEILING(1 + HeaderValue(object), 2); + + closure = (struct closure *) ptr; + + asm_label(ptr, object, f); + asm_header_word(ptr, object, f, "closure header"); + fprintf(f, "\t.4byte\tL%08lx\n", closure->function); + + nwords -= 2; + + for (k = 0; k < nwords; ++k) { + asm_lispobj(closure->info + k, closure->info[k], f); + + } + return nwords; } int @@ -1188,6 +1206,61 @@ init_asmtab(void) { int k = 0; + /* Initialize type labels */ + for (k = 0; k < 256; ++k) { + asmtab_types[k] = ""; + } + + asmtab_types[type_Bignum] = "Bignum"; + asmtab_types[type_Ratio] = "Ratio"; + asmtab_types[type_SingleFloat] = "SingleFloat"; + asmtab_types[type_DoubleFloat] = "DoubleFloat"; + asmtab_types[type_DoubleDoubleFloat] = "DoubleDoubleFloat"; + asmtab_types[type_Complex] = "Complex"; + asmtab_types[type_ComplexSingleFloat] = "ComplexSingleFloat"; + asmtab_types[type_ComplexDoubleFloat] = "ComplexDoubleFloat"; + asmtab_types[type_ComplexDoubleDoubleFloat] = "ComplexDoubleDoubleFloat"; + asmtab_types[type_SimpleArray] = "SimpleArray"; + asmtab_types[type_SimpleString] = "SimpleString"; + asmtab_types[type_SimpleBitVector] = "SimpleBitVector"; + asmtab_types[type_SimpleVector] = "SimpleVector"; + asmtab_types[type_SimpleArrayUnsignedByte2] = "SimpleArrayUnsignedByte2"; + asmtab_types[type_SimpleArrayUnsignedByte4] = "SimpleArrayUnsignedByte4"; + asmtab_types[type_SimpleArrayUnsignedByte8] = "SimpleArrayUnsignedByte8"; + asmtab_types[type_SimpleArrayUnsignedByte16] = "SimpleArrayUnsignedByte16"; + asmtab_types[type_SimpleArrayUnsignedByte32] = "SimpleArrayUnsignedByte32"; + asmtab_types[type_SimpleArraySignedByte8] = "SimpleArraySignedByte8"; + asmtab_types[type_SimpleArraySignedByte16] = "SimpleArraySignedByte16"; + asmtab_types[type_SimpleArraySignedByte30] = "SimpleArraySignedByte30"; + asmtab_types[type_SimpleArraySignedByte32] = "SimpleArraySignedByte32"; + asmtab_types[type_SimpleArraySingleFloat] = "SimpleArraySingleFloat"; + asmtab_types[type_SimpleArrayDoubleFloat] = "SimpleArrayDoubleFloat"; + asmtab_types[type_SimpleArrayDoubleDoubleFloat] = "SimpleArrayDoubleDoubleFloat"; + asmtab_types[type_SimpleArrayComplexSingleFloat] = "SimpleArrayComplexSingleFloat"; + asmtab_types[type_SimpleArrayComplexDoubleFloat] = "SimpleArrayComplexDoubleFloat"; + asmtab_types[type_SimpleArrayComplexDoubleDoubleFloat] = "SimpleArrayComplexDoubleDoubleFloat"; + asmtab_types[type_ComplexString] = "ComplexString"; + asmtab_types[type_ComplexBitVector] = "ComplexBitVector"; + asmtab_types[type_ComplexVector] = "ComplexVector"; + asmtab_types[type_ComplexArray] = "ComplexArray"; + asmtab_types[type_CodeHeader] = "CodeHeader"; + asmtab_types[type_FunctionHeader] = "FunctionHeader"; + asmtab_types[type_ClosureHeader] = "ClosureHeader"; + asmtab_types[type_FuncallableInstanceHeader] = "FuncallableInstanceHeader"; + asmtab_types[type_ByteCodeFunction] = "ByteCodeFunction"; + asmtab_types[type_ByteCodeClosure] = "ByteCodeClosure"; + asmtab_types[type_ClosureFunctionHeader] = "ClosureFunctionHeader"; + asmtab_types[type_ReturnPcHeader] = "ReturnPcHeader"; + asmtab_types[type_ValueCellHeader] = "ValueCellHeader"; + asmtab_types[type_SymbolHeader] = "SymbolHeader"; + asmtab_types[type_BaseChar] = "BaseChar"; + asmtab_types[type_Sap] = "Sap"; + asmtab_types[type_UnboundMarker] = "UnboundMarker"; + asmtab_types[type_WeakPointer] = "WeakPointer"; + asmtab_types[type_InstanceHeader] = "InstanceHeader"; + asmtab_types[type_Fdefn] = "Fdefn"; + asmtab_types[type_ScavengerHook] = "ScavengerHook"; + for (k = 0; k < 256; ++k) { asmtab[k] = asm_ni; } View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/commit/2f2f9ba8db53aac8b2ce05b… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/commit/2f2f9ba8db53aac8b2ce05b… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl][native-image] Handle case of code header with no entry points.
by Raymond Toy 09 Feb '21

09 Feb '21

Raymond Toy pushed to branch native-image at cmucl / cmucl Commits: 93c256ba by Raymond Toy at 2021-02-08T16:37:40-08:00 Handle case of code header with no entry points. We were just skipping that case, incorrectly. Makes the read-only space print out the instructions for the assembly routines. While we're at it, dump out the dynamic space too. - - - - - 1 changed file: - src/lisp/save.c Changes: ===================================== src/lisp/save.c ===================================== @@ -27,6 +27,16 @@ #include "gencgc.h" #endif +/* + * Aargh! Why is SPARC so different here? What is the advantage of + * making it different from all the other ports? + */ +#if defined(sparc) || (defined(DARWIN) && defined(__ppc__)) +#define RAW_ADDR_OFFSET 0 +#else +#define RAW_ADDR_OFFSET (6 * sizeof(lispobj) - type_FunctionPointer) +#endif + /* Like (ceiling x y), but y is constrained to be a power of two */ #define CEILING(x,y) (((x) + ((y) - 1)) & (~((y) - 1))) @@ -371,9 +381,13 @@ save_executable(char *filename, lispobj init_function) #ifdef reg_ALLOC write_space_object(dir_name, DYNAMIC_SPACE_ID, (os_vm_address_t)current_dynamic_space, (os_vm_address_t)current_dynamic_space_free_pointer); + write_asm_object(dir_name, DYNAMIC_SPACE_ID, (os_vm_address_t)current_dynamic_space, + (os_vm_address_t)current_dynamic_space_free_pointer); #else write_space_object(dir_name, DYNAMIC_SPACE_ID, (os_vm_address_t)current_dynamic_space, (os_vm_address_t)SymbolValue(ALLOCATION_POINTER)); + write_asm_object(dir_name, DYNAMIC_SPACE_ID, (os_vm_address_t)current_dynamic_space, + (os_vm_address_t)SymbolValue(ALLOCATION_POINTER)); #endif printf("\tdone]\n"); @@ -530,6 +544,14 @@ asm_fdefn(lispobj* ptr, lispobj object, FILE* f) asm_lispobj(ptr + 1, ptr[1], f); asm_lispobj(ptr + 2, ptr[2], f); +#if 0 + struct fdefn* fdefn = (struct fdefn*) ptr; + + if (((char *) (fdefn->function + RAW_ADDR_OFFSET) != fdefn->raw_addr)) { + fprintf(f, "# Different!\n"); + } +#endif + fprintf(f, "\t.4byte\tL%lx\t# raw_addr\n", (unsigned long) ptr[3]); return 4; @@ -678,6 +700,15 @@ asm_code_header(lispobj* ptr, lispobj object, FILE* f) fheaderl = fheaderp->next; } + { + uint32_t* code_data = (uint32_t*) fheaderp->code; + + for (k = 0; k < ncode_words; ++k) { + fprintf(f, "\t.4byte\t0x%08x\t# %p\n", code_data[k], + fheaderp->code + 4*k); + } + } + asm_align(f); return nwords; } View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/commit/93c256baa6e0b526f3875e7… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/commit/93c256baa6e0b526f3875e7… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl][native-image] 9 commits: Add complex double-double-float
by Raymond Toy 07 Feb '21

07 Feb '21

Raymond Toy pushed to branch native-image at cmucl / cmucl Commits: e35e9f7a by Raymond Toy at 2021-02-06T13:33:21-08:00 Add complex double-double-float Remove some old #if'd out code. - - - - - 96e7aa5e by Raymond Toy at 2021-02-06T13:55:09-08:00 Add bit vector and double-float vector - - - - - 57ceca08 by Raymond Toy at 2021-02-06T14:05:39-08:00 Add vectyor unsigned-byte 16 - - - - - 9e4049c6 by Raymond Toy at 2021-02-06T14:14:55-08:00 Add vector unsigned-byte 2 - - - - - 44913576 by Raymond Toy at 2021-02-06T14:20:12-08:00 Add vector unsigned-byte 4 - - - - - e2cecd5f by Raymond Toy at 2021-02-06T14:38:03-08:00 Print hex values for floats The gcc assembler can't handle most-positive-double-float (when printed by C), so let's just print out the 32-bit words of the double with a comment on the actual value. - - - - - 55c9c196 by Raymond Toy at 2021-02-06T14:42:16-08:00 Add comment on where we need to apply code fixups. - - - - - 0a553364 by Raymond Toy at 2021-02-07T09:47:06-08:00 Fix handling of code header and symbol headers Printing of the symbol header was broken because we printed out the unbound marker as Lba, indicating an address. But we just want the raw value of the unbound marker The code header consists of multiple function header objects so we dump each of the objects now. Finally a few changes on printing: * asm_word uses %08lx to the value * asm_lispobj prints out the address with %08lx to be consistent with asm_label. - - - - - a31b485f by Raymond Toy at 2021-02-07T10:03:17-08:00 asm_lispobj handles immediates If the object is an even or odd immediate, just print out the value since it's, duh, an immediate, not some kind of address or fixnum. asm_symbol_header doesn't need the special case for the value slot anymore. (We can probably replace this with just asm_boxed as we did before.) - - - - - 1 changed file: - src/lisp/save.c Changes: ===================================== src/lisp/save.c ===================================== @@ -407,7 +407,7 @@ asm_word(lispobj* ptr, lispobj object, FILE* f) { unsigned long val = (unsigned long) object; - fprintf(f, "\t.4byte\t0x%lx\t# %ld\n", val, val); + fprintf(f, "\t.4byte\t0x%08lx\t# %ld\n", val, val); } void @@ -419,8 +419,12 @@ asm_lispobj(lispobj* ptr, lispobj object, FILE* f) fprintf(f, "0x%lx\t# fixnum %ld\n", (long) object, ((long) object) >> 2); + } else if ((object & 7) == 2 || + (object & 7) == 6) { + /* Other immediates */ + fprintf(f, "0x%08lx\n", object); } else { - fprintf(f, "L%lx + %lu\n", PTR(object), LowtagOf(object)); + fprintf(f, "L%08lx + %lu\n", PTR(object), LowtagOf(object)); } } @@ -564,6 +568,22 @@ asm_closure_header(lispobj* ptr, lispobj object, FILE* f) return asm_boxed(ptr, object, f); } +int +asm_symbol_header(lispobj* ptr, lispobj object, FILE* f) +{ + struct symbol* sym = (struct symbol*) ptr; + + asm_label(ptr, object, f); + asm_header_word(ptr, object, f, "symbol header"); + asm_lispobj(&sym->value, sym->value, f); + asm_lispobj(&sym->hash, sym->hash, f); + asm_lispobj(&sym->plist, sym->plist, f); + asm_lispobj(&sym->name, sym->name, f); + asm_lispobj(&sym->package, sym->package, f); + + return 1 + HeaderValue(object); +} + int asm_complex_vector(lispobj* ptr, lispobj object, FILE* f) { @@ -578,6 +598,8 @@ asm_code_header(lispobj* ptr, lispobj object, FILE* f) int ncode_words; int nwords; int k; + lispobj fheaderl; + struct function *fheaderp; code = (struct code *) ptr; ncode_words = fixnum_value(code->code_size); @@ -597,12 +619,66 @@ asm_code_header(lispobj* ptr, lispobj object, FILE* f) asm_lispobj(ptr + k + 1, ptr[k + 1], f); } - fprintf(f, "# Code bytes?\n"); - - for (; k < nwords; ++k) { - fprintf(f, "\t.4byte\t0x%lx\n", ptr[k + 1]); + fheaderl = code->entry_points; + while (fheaderl != NIL) { + int code_words; + int fheader_len; + + fheaderp = (struct function *) PTR(fheaderl); + fheader_len = HeaderValue(fheaderp->header); +#if 0 + fprintf(f, "# fheaderp %p\n", (void*) fheaderp); + fprintf(f, "# ->header 0x%lx\n", fheaderp->header); + fprintf(f, "# ->self 0x%lx\n", fheaderp->self); + fprintf(f, "# ->next 0x%lx\n", fheaderp->next); + fprintf(f, "# ->name 0x%lx\n", fheaderp->name); + fprintf(f, "# ->arglist 0x%lx\n", fheaderp->arglist); + fprintf(f, "# ->type 0x%lx\n", fheaderp->type); + fprintf(f, "# ->code %p\n", &fheaderp->code); +#endif + asm_label((lispobj*)fheaderp, *((lispobj*)fheaderp), f); + asm_header_word(&fheaderp->header, fheaderp->header, f, "function header"); + fprintf(f, "\t.4byte\tL%lx\n", fheaderp->self); + asm_lispobj(&fheaderp->next, fheaderp->next, f); + asm_lispobj(&fheaderp->name, fheaderp->name, f); + asm_lispobj(&fheaderp->arglist, fheaderp->arglist, f); + asm_lispobj(&fheaderp->type, fheaderp->type, f); + asm_label((lispobj*)fheaderp->code, 0, f); + + /* We've sent out 6 of the total code words */ + ncode_words -= fheader_len; + + /* + * TODO: Adopt trans_code or apply_code_fixups to process the code + * here so we can relocate everthing. + */ + fprintf(f, "# Code bytes\n"); + + /* Dump out code between here and the next function header */ + if (fheaderp->next != NIL) { + code_words = (fheaderp->next - fheaderl) / 4 - fheader_len; + } else { + code_words = ncode_words; + } + + fprintf(f, "# fheaderp->next %p code words %d ncode_words %d\n", + (void*)fheaderp->next, code_words, ncode_words); + + { + uint32_t* code_data = (uint32_t*) fheaderp->code; + + for (k = 0; k < code_words; ++k) { + fprintf(f, "\t.4byte\t0x%08x\t# %p\n", code_data[k], + fheaderp->code + 4*k); + } + } + + ncode_words -= code_words; + + fheaderl = fheaderp->next; } - + + asm_align(f); return nwords; } @@ -659,9 +735,42 @@ asm_simple_string(lispobj* where, lispobj object, FILE* f) return nwords; } +int +asm_vector_bit(lispobj* ptr, lispobj object, FILE* f) +{ + struct vector *vector; + int length, nwords; + unsigned long* data; + int k; + + + vector = (struct vector *) ptr; + length = fixnum_value(vector->length); +#ifdef __x86_64 + nwords = CEILING(NWORDS(length, 64) + 2, 2); +#else + nwords = CEILING(NWORDS(length, 32) + 2, 2); +#endif + + asm_label(ptr, object, f); + asm_header_word(ptr, object, f, "simple bit-vector"); + asm_lispobj(ptr + 1, ptr[1], f); + + data = vector->data; + + for (k = 0; k < nwords - 2; ++k) { + fprintf(f, "\t.4byte\t0x%lx\n", data[k]); + } + + return nwords; + +} + + void print_float(FILE* f, float value) { +#if 0 if (isfinite(value)) { fprintf(f, "\t.float\t%.15g\n", value); } else { @@ -674,6 +783,17 @@ print_float(FILE* f, float value) val.f = value; fprintf(f, "\t.4byte\t0x%x\n", val.a); } +#else + union + { + uint32_t a; + float f; + } val; + + val.f = value; + fprintf(f, "\t.4byte\t0x%x\t# %lg\n", val.a, value); +#endif + } int @@ -684,7 +804,6 @@ asm_single_float(lispobj* ptr, lispobj object, FILE* f) asm_label(ptr, object, f); asm_header_word(ptr, object, f, "single float"); print_float(f, obj->value); - return 2; } @@ -692,8 +811,9 @@ asm_single_float(lispobj* ptr, lispobj object, FILE* f) void print_double(FILE* f, double value) { +#if 0 if (isfinite(value)) { - fprintf(f, "\t.double\t%.15g\n", value); + fprintf(f, "\t.double\t%.16lg\n", value); } else { union { @@ -706,6 +826,18 @@ print_double(FILE* f, double value) fprintf(f, "\t.4byte\t0x%x\n", val.a[0]); fprintf(f, "\t.4byte\t0x%x\n", val.a[1]); } +#else + union + { + uint32_t a[2]; + double d; + } val; + + val.d = value; + fprintf(f, "\t.4byte\t0x%x\t# %.18lg\n", val.a[0], value); + fprintf(f, "\t.4byte\t0x%x\n", val.a[1]); + +#endif } int @@ -751,9 +883,41 @@ asm_complex_single_float(lispobj* ptr, lispobj object, FILE* f) return CEILING(1 + HeaderValue(object), 2); } +int +asm_complex_double_float(lispobj* ptr, lispobj object, FILE* f) +{ + struct complex_double_float* obj = (struct complex_double_float*) ptr; + + asm_label(ptr, object, f); + asm_header_word(ptr, object, f, "complex double-float"); + asm_lispobj(&obj->filler, obj->filler, f); + + print_double(f, obj->real); + print_double(f, obj->imag); + return CEILING(1 + HeaderValue(object), 2); +} + int -asm_vector_unsigned_byte_8(lispobj* ptr, lispobj object, FILE* f) +asm_complex_double_double_float(lispobj* ptr, lispobj object, FILE* f) +{ + struct complex_double_double_float* obj = (struct complex_double_double_float*) ptr; + + asm_label(ptr, object, f); + asm_header_word(ptr, object, f, "complex double-float"); + asm_lispobj(&obj->filler, obj->filler, f); + + print_double(f, obj->real_hi); + print_double(f, obj->real_lo); + print_double(f, obj->imag_hi); + print_double(f, obj->imag_lo); + + return CEILING(1 + HeaderValue(object), 2); +} + + +int +asm_vector_unsigned_byte_2(lispobj* ptr, lispobj object, FILE* f) { struct vector *vector; int length, nwords; @@ -763,12 +927,12 @@ asm_vector_unsigned_byte_8(lispobj* ptr, lispobj object, FILE* f) vector = (struct vector *) ptr; length = fixnum_value(vector->length); #ifdef __x86_64 - nwords = CEILING(NWORDS(length, 8) + 2, 2); + nwords = CEILING(NWORDS(length, 32) + 2, 2); #else - nwords = CEILING(NWORDS(length, 4) + 2, 2); + nwords = CEILING(NWORDS(length, 16) + 2, 2); #endif asm_label(ptr, object, f); - asm_header_word(ptr, object, f, "vector unsigned_byte 8"); + asm_header_word(ptr, object, f, "vector unsigned_byte 2"); asm_lispobj(ptr + 1, ptr[1], f); data = vector->data; @@ -777,12 +941,14 @@ asm_vector_unsigned_byte_8(lispobj* ptr, lispobj object, FILE* f) for (k = 0; k < nwords - 2; ++k) { fprintf(f, "\t.4byte\t0x%lx\n", data[k]); } + + asm_align(f); return nwords; } int -asm_vector_unsigned_byte_32(lispobj* ptr, lispobj object, FILE* f) +asm_vector_unsigned_byte_4(lispobj* ptr, lispobj object, FILE* f) { struct vector *vector; int length, nwords; @@ -792,13 +958,12 @@ asm_vector_unsigned_byte_32(lispobj* ptr, lispobj object, FILE* f) vector = (struct vector *) ptr; length = fixnum_value(vector->length); #ifdef __x86_64 - nwords = CEILING(NWORDS(length, 2) + 2, 2); + nwords = CEILING(NWORDS(length, 16) + 2, 2); #else - nwords = CEILING(length + 2, 2); + nwords = CEILING(NWORDS(length, 8) + 2, 2); #endif - asm_label(ptr, object, f); - asm_header_word(ptr, object, f, "vector unsigned_byte 32"); + asm_header_word(ptr, object, f, "vector unsigned_byte 4"); asm_lispobj(ptr + 1, ptr[1], f); data = vector->data; @@ -807,113 +972,186 @@ asm_vector_unsigned_byte_32(lispobj* ptr, lispobj object, FILE* f) for (k = 0; k < nwords - 2; ++k) { fprintf(f, "\t.4byte\t0x%lx\n", data[k]); } + + asm_align(f); return nwords; } int -asm_bignum(lispobj* ptr, lispobj object, FILE* f) +asm_vector_unsigned_byte_8(lispobj* ptr, lispobj object, FILE* f) { - int len = 1 + HeaderValue(object); + struct vector *vector; + int length, nwords; + unsigned long* data; int k; - - len = CEILING(len, 2); + vector = (struct vector *) ptr; + length = fixnum_value(vector->length); +#ifdef __x86_64 + nwords = CEILING(NWORDS(length, 8) + 2, 2); +#else + nwords = CEILING(NWORDS(length, 4) + 2, 2); +#endif asm_label(ptr, object, f); - asm_header_word(ptr, object, f, "bignum"); + asm_header_word(ptr, object, f, "vector unsigned_byte 8"); + asm_lispobj(ptr + 1, ptr[1], f); - for (k = 1; k < len; ++k) { - fprintf(f, "\t.4byte\t0x%lx\t# %lu\n", ptr[k], ptr[k]); - } + data = vector->data; - return len; + /* Minus 2 for the header and length words */ + for (k = 0; k < nwords - 2; ++k) { + fprintf(f, "\t.4byte\t0x%lx\n", data[k]); + } + + return nwords; } int -asm_sap(lispobj* ptr, lispobj object, FILE* f) +asm_vector_unsigned_byte_16(lispobj* ptr, lispobj object, FILE* f) { + struct vector *vector; + int length, nwords; + uint16_t* data; + int k; + + vector = (struct vector *) ptr; + length = fixnum_value(vector->length); +#ifdef __x86_64 + nwords = CEILING(NWORDS(length, 4) + 2, 2); +#else + nwords = CEILING(NWORDS(length, 2) + 2, 2); +#endif asm_label(ptr, object, f); - asm_header_word(ptr, object, f, "sap"); - /* Just print out the raw value of the address */ - fprintf(f, "\t.4byte\t0x%lx\n", ptr[1]); + asm_header_word(ptr, object, f, "vector unsigned_byte 16"); + asm_lispobj(ptr + 1, ptr[1], f); + + data = (uint16_t*) vector->data; - return 2; -} + /* Minus 2 for the header and length words */ + for (k = 0; k < length; ++k) { + fprintf(f, "\t.4byte\t0x%x\n", data[k]); + } + + asm_align(f); -#if 0 -int -asm_catch_block(lispobj* ptr, lispobj object, FILE* f) -{ - return asm_boxed(ptr, object, f); + return nwords; } int -asm_catch_block(lispobj* ptr, lispobj object, FILE* f) +asm_vector_unsigned_byte_32(lispobj* ptr, lispobj object, FILE* f) { - return asm_boxed(ptr, object, f); -} + struct vector *vector; + int length, nwords; + unsigned long* data; + int k; + + vector = (struct vector *) ptr; + length = fixnum_value(vector->length); +#ifdef __x86_64 + nwords = CEILING(NWORDS(length, 2) + 2, 2); +#else + nwords = CEILING(length + 2, 2); +#endif -int -asm_closure(lispobj* ptr, lispobj object, FILE* f) -{ - return asm_boxed(ptr, object, f); -} + asm_label(ptr, object, f); + asm_header_word(ptr, object, f, "vector unsigned_byte 32"); + asm_lispobj(ptr + 1, ptr[1], f); + + data = vector->data; -int -asm_code(lispobj* ptr, lispobj object, FILE* f) -{ - return asm_boxed(ptr, object, f); + /* Minus 2 for the header and length words */ + for (k = 0; k < nwords - 2; ++k) { + fprintf(f, "\t.4byte\t0x%lx\n", data[k]); + } + + return nwords; } int -asm_complex(lispobj* ptr, lispobj object, FILE* f) +asm_vector_double_float(lispobj* ptr, lispobj object, FILE* f) { - return asm_boxed(ptr, object, f); -} + struct vector *vector; + int length, nwords; + const double* data; + int k; + + vector = (struct vector *) ptr; + length = fixnum_value(vector->length); +#ifdef __x86_64 + nwords = CEILING(length + 2, 2); +#else + nwords = length * 2 + 2; /* alignment guaranteed */ +#endif -int -asm_complex_double_double_float(lispobj* ptr, lispobj object, FILE* f) -{ asm_label(ptr, object, f); - asm_lispobj(ptr, object, f); + asm_header_word(ptr, object, f, "vector double-float"); asm_lispobj(ptr + 1, ptr[1], f); - - double* d = (double*) (ptr + 2); - for (k = 0; k < 4; ++k) { - fprintf(f, "\t.double\t%.15lg\n", d[k]); + data = (const double*) vector->data; + + + for (k = 0; k < length; ++k) { + print_double(f, data[k]); } - return HeaderValue(object); + return nwords; } int -asm_complex_double_float(lispobj* ptr, lispobj object, FILE* f) +asm_vector_double_double_float(lispobj* ptr, lispobj object, FILE* f) { + struct vector *vector; + int length, nwords; + const double* data; + int k; + + vector = (struct vector *) ptr; + length = fixnum_value(vector->length); + nwords = CEILING(length * 4 + 2, 2); + asm_label(ptr, object, f); - asm_lispobj(ptr, object, f); + asm_header_word(ptr, object, f, "vector double-float"); asm_lispobj(ptr + 1, ptr[1], f); + + data = (const double*) vector->data; - double* d = ptr + 2; - fprintf(f, "\t.double\t%.15lg, %.15lg\n", d[0], d[1]); + for (k = 0; k < 2*length; ++k) { + print_double(f, data[k]); + } - return HeaderValue(object); + return nwords; } int -asm_complex_double_float(lispobj* ptr, lispobj object, FILE* f) +asm_bignum(lispobj* ptr, lispobj object, FILE* f) { - asm_label(ptr, object, f); - asm_lispobj(ptr, object, f); + int len = 1 + HeaderValue(object); + int k; - double* d = ptr + 2; - fprintf(f, "\t.double\t%.15lg, %.15lg\n", d[0], d[1]); + len = CEILING(len, 2); + + asm_label(ptr, object, f); + asm_header_word(ptr, object, f, "bignum"); + + for (k = 1; k < len; ++k) { + fprintf(f, "\t.4byte\t0x%lx\t# %lu\n", ptr[k], ptr[k]); + } - return HeaderValue(object); + return len; } -#endif +int +asm_sap(lispobj* ptr, lispobj object, FILE* f) +{ + asm_label(ptr, object, f); + asm_header_word(ptr, object, f, "sap"); + /* Just print out the raw value of the address */ + fprintf(f, "\t.4byte\t0x%lx\n", ptr[1]); + return 2; +} + void init_asmtab(void) { @@ -941,11 +1179,19 @@ init_asmtab(void) asmtab[type_DoubleDoubleFloat] = asm_double_double_float; asmtab[type_Complex] = asm_boxed; asmtab[type_ComplexSingleFloat] = asm_complex_single_float; + asmtab[type_ComplexDoubleFloat] = asm_complex_double_float; + asmtab[type_ComplexDoubleDoubleFloat] = asm_complex_double_double_float; asmtab[type_SimpleArray] = asm_boxed; asmtab[type_SimpleString] = asm_simple_string; + asmtab[type_SimpleBitVector] = asm_vector_bit; asmtab[type_SimpleVector] = asm_simple_vector; + asmtab[type_SimpleArrayUnsignedByte2] = asm_vector_unsigned_byte_2; + asmtab[type_SimpleArrayUnsignedByte4] = asm_vector_unsigned_byte_4; asmtab[type_SimpleArrayUnsignedByte8] = asm_vector_unsigned_byte_8; + asmtab[type_SimpleArrayUnsignedByte16] = asm_vector_unsigned_byte_16; asmtab[type_SimpleArrayUnsignedByte32] = asm_vector_unsigned_byte_32; + asmtab[type_SimpleArrayDoubleFloat] = asm_vector_double_float; + asmtab[type_SimpleArrayDoubleDoubleFloat] = asm_vector_double_double_float; asmtab[type_ComplexString] = asm_boxed; asmtab[type_ComplexVector] = asm_boxed; asmtab[type_CodeHeader] = asm_code_header; @@ -953,7 +1199,7 @@ init_asmtab(void) asmtab[type_FuncallableInstanceHeader] = asm_closure_header; /* Just use asm_boxed or have a special version for a value cell? */ asmtab[type_ValueCellHeader] = asm_boxed; - asmtab[type_SymbolHeader] = asm_boxed; + asmtab[type_SymbolHeader] = asm_symbol_header; asmtab[type_BaseChar] = asm_immediate; asmtab[type_Sap] = asm_sap; asmtab[type_InstanceHeader] = asm_boxed; @@ -966,6 +1212,9 @@ write_asm_object(const char *dir, int id, os_vm_address_t start, os_vm_address_t char asm_file[PATH_MAX]; FILE* f; + printf("write_asm_object space %d start %p end %p\n", + id, start, end); + snprintf(asm_file, PATH_MAX, "%s/space-%d.s", dir, id); f = fopen(asm_file, "w"); View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/07991ccceb9f092900f7b5… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/07991ccceb9f092900f7b5… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl][native-image] 17 commits: Update CI to use 2021-01 snapshot
by Raymond Toy 06 Feb '21

06 Feb '21

Raymond Toy pushed to branch native-image at cmucl / cmucl Commits: a3e42a4c by Raymond Toy at 2021-02-03T19:57:26-08:00 Update CI to use 2021-01 snapshot Binaries for the 2021-01 snapshot are available so use those instead of doing a cross-compile from 2020-04. - - - - - 84fa2568 by Raymond Toy at 2021-02-03T20:11:21-08:00 Set version correctly Updated the directory path but forgot the version part. - - - - - 408711a9 by Raymond Toy at 2021-02-04T04:31:04+00:00 Merge branch 'update-ci-snapshot-2021-01' into 'master' Update CI to use 2021-01 snapshot See merge request cmucl/cmucl!69 - - - - - 8f18e12c by Raymond Toy at 2021-02-05T05:14:29+00:00 Fix #101: Add -ftrapping-math to clang compiler options Because lisp runs with FP traps enabled, we want the C code to honor that. Hence add -ftrapping-math. Also cleaned up the options, replacing -march=pentium4 and -mtune=generic with just -mtune=pentiume4. Replace -mfpmath=sse (not sure what that does) with -msse2. Finally, update CI to do a clang build so we can verify this actually works. - - - - - f99321c7 by Raymond Toy at 2021-02-05T05:14:29+00:00 Merge branch 'issue-101-clang-trapping-math' into 'master' Fix #101: Add -ftrapping-math to clang compiler options Closes #101 See merge request cmucl/cmucl!70 - - - - - 66b9257b by Raymond Toy at 2021-02-05T12:58:26-08:00 Merge branch 'master' into native-image - - - - - c9388194 by Raymond Toy at 2021-02-06T08:28:20-08:00 Reorder asmtab entries and enable writing read-only space Make the asmtab entries in the same order as the type values themselves. - - - - - 5608c220 by Raymond Toy at 2021-02-06T09:06:31-08:00 Add code header Also add extra arg to asm_header_word to allow printing notes with the header word. - - - - - 4d99c860 by Raymond Toy at 2021-02-06T10:05:57-08:00 Add simple_string, single_float, and double_float - - - - - 4dfcda48 by Raymond Toy at 2021-02-06T10:22:02-08:00 Add vector unsigned-byte 8 - - - - - b8897129 by Raymond Toy at 2021-02-06T10:27:58-08:00 Add closure_header - - - - - 18459e79 by Raymond Toy at 2021-02-06T10:31:39-08:00 Add vector unsiged-byte 32 - - - - - 08b2c144 by Raymond Toy at 2021-02-06T10:39:27-08:00 Add bignum - - - - - 81c4f955 by Raymond Toy at 2021-02-06T10:47:02-08:00 Add sap Adjust printing of bignums a bit to include hex and decimal values. - - - - - d3565cb8 by Raymond Toy at 2021-02-06T11:21:35-08:00 Print out the characters in a simple string for debugging. - - - - - f3051655 by Raymond Toy at 2021-02-06T11:44:18-08:00 Add double double float Also adjust how single and double floats are dumped because sometimes the values are infinity or NaN, and we want exactly those bits dumped. - - - - - 07991ccc by Raymond Toy at 2021-02-06T12:00:50-08:00 Add complex single-float Also define functions for printing floats and doubles so we can use the same routine for complex floats too. - - - - - 3 changed files: - .gitlab-ci.yml - src/lisp/Config.x86_linux_clang - src/lisp/save.c Changes: ===================================== .gitlab-ci.yml ===================================== @@ -1,12 +1,13 @@ variables: - download_url: "https://common-lisp.net/project/cmucl/downloads/snapshots/2020/04" - version: "2020-04-x86" + download_url: "https://common-lisp.net/project/cmucl/downloads/snapshots/2021/01" + version: "2021-01-x86" bootstrap: "" stages: - install - build - test + - ansi-test - benchmark cache: @@ -37,11 +38,11 @@ linux:build: artifacts: true script: # Do cross compile first - - bin/create-target.sh xtarget x86_linux_clang - - bin/create-target.sh xcross x86_linux_clang - - bin/cross-build-world.sh -crl -B boot-2020-04-1 xtarget xcross src/tools/cross-scripts/cross-x86-x86.lisp snapshot/bin/lisp - # Regular build using the cross-compiled result - - bin/build.sh $bootstrap -R -C "" -o xtarget/lisp/lisp + #- bin/create-target.sh xtarget x86_linux_clang + #- bin/create-target.sh xcross x86_linux_clang + #- bin/cross-build-world.sh -crl -B boot-2020-04-1 xtarget xcross src/tools/cross-scripts/cross-x86-x86.lisp snapshot/bin/lisp + # Regular build using the cross-compiled result or snapshot + - bin/build.sh $bootstrap -R -C "x86_linux_clang" -o snapshot/bin/lisp - bin/make-dist.sh -I dist linux-4 linux:test: @@ -56,15 +57,28 @@ linux:test: # Needs artifacts from build (dist/) - job: linux:build artifacts: true + script: + - bin/run-tests.sh -l dist/bin/lisp 2>&1 | tee test.log + +linux:ansi-test: + stage: ansi-test + tags: + - linux + artifacts: + paths: + - ansi-test/test.out + needs: + # Needs artifacts from build (dist/) + - job: linux:build + artifacts: true before_script: - git clone https://gitlab.common-lisp.net/cmucl/ansi-test.git - (cd ansi-test; git checkout rtoy-cmucl-expected-failures) script: - - bin/run-tests.sh -l dist/bin/lisp 2>&1 | tee test.log - cd ansi-test - make LISP="../dist/bin/lisp -batch -noinit -nositeinit" - grep 'No unexpected $successes\|failures$' test.out - + linux:benchmark: stage: benchmark tags: @@ -108,11 +122,11 @@ osx:build: artifacts: true script: # Do cross compile first - - bin/create-target.sh xtarget x86_darwin - - bin/create-target.sh xcross x86_darwin - - bin/cross-build-world.sh -crl -B boot-2020-04-1 xtarget xcross src/tools/cross-scripts/cross-x86-x86.lisp snapshot/bin/lisp - # Regular build using the cross-compiled result - - bin/build.sh $bootstrap -R -C "" -o xtarget/lisp/lisp + #- bin/create-target.sh xtarget x86_darwin + #- bin/create-target.sh xcross x86_darwin + #- bin/cross-build-world.sh -crl -B boot-2020-04-1 xtarget xcross src/tools/cross-scripts/cross-x86-x86.lisp snapshot/bin/lisp + # Regular build using the cross-compiled result or snapshot + - bin/build.sh $bootstrap -R -C "" -o snapshot/bin/lisp - bin/make-dist.sh -I dist darwin-4 osx:test: @@ -121,21 +135,33 @@ osx:test: - osx artifacts: paths: - - ansi-test/test.out - test.log needs: # Needs artifacts from build (dist/) - job: osx:build artifacts: true + script: + - bin/run-tests.sh -l dist/bin/lisp 2>&1 | tee test.log + +osx:ansi-test: + stage: ansi-test + tags: + - osx + artifacts: + paths: + - ansi-test/test.out + needs: + # Needs artifacts from build (dist/) + - job: osx:build + artifacts: true before_script: - git clone https://gitlab.common-lisp.net/cmucl/ansi-test.git - (cd ansi-test; git checkout rtoy-cmucl-expected-failures) script: - - bin/run-tests.sh -l dist/bin/lisp 2>&1 | tee test.log - cd ansi-test - make LISP="../dist/bin/lisp -batch -noinit -nositeinit" - grep 'No unexpected $successes\|failures$' test.out - + osx:benchmark: stage: benchmark tags: ===================================== src/lisp/Config.x86_linux_clang ===================================== @@ -4,7 +4,11 @@ include Config.x86_common CC = clang CPPFLAGS += -m32 -D__NO_CTYPE -D_GNU_SOURCE CFLAGS += $(COPT) -CFLAGS += -march=pentium4 -mfpmath=sse -mtune=generic + +# Allow sse2 instructions (-msse2); and tune for pentium4 +# (-mtune=pentium4), the first chip to have sse2; and finally generate +# code assuming instructions can trap (-ftrapping-math). +CFLAGS += -msse2 -mtune=pentium4 -ftrapping-math UNDEFSYMPATTERN = -Xlinker -u -Xlinker & ASSEM_SRC += linux-stubs.S ===================================== src/lisp/save.c ===================================== @@ -11,6 +11,7 @@ #include <stdlib.h> #include <string.h> #include <limits.h> +#include <math.h> #include "lisp.h" #include "os.h" @@ -29,6 +30,8 @@ /* Like (ceiling x y), but y is constrained to be a power of two */ #define CEILING(x,y) (((x) + ((y) - 1)) & (~((y) - 1))) +#define NWORDS(x,y) (CEILING((x),(y)) / (y)) + #ifdef FEATURE_EXECUTABLE #include "elf.h" #if !(defined(DARWIN) && defined(__ppc__)) @@ -309,8 +312,10 @@ save_executable(char *filename, lispobj init_function) (os_vm_address_t)SymbolValue(STATIC_SPACE_FREE_POINTER)); + write_asm_object(dir_name, READ_ONLY_SPACE_ID, (os_vm_address_t)read_only_space, + (os_vm_address_t)SymbolValue(READ_ONLY_SPACE_FREE_POINTER)); write_asm_object(dir_name, STATIC_SPACE_ID, (os_vm_address_t)static_space, - (os_vm_address_t)SymbolValue(STATIC_SPACE_FREE_POINTER)); + (os_vm_address_t)SymbolValue(STATIC_SPACE_FREE_POINTER)); #ifdef GENCGC /* Flush the current_region updating the tables. */ @@ -432,12 +437,12 @@ asm_align(FILE* f) } void -asm_header_word(lispobj* ptr, lispobj object, FILE* f) +asm_header_word(lispobj* ptr, lispobj object, FILE* f, const char* note) { unsigned long len = HeaderValue(object); unsigned long type = TypeOf(object); - fprintf(f, "\t.4byte\t0x%lx << 8 + %ld\n", len, type); + fprintf(f, "\t.4byte\t0x%lx << 8 + %ld\t# %s\n", len, type, note); } @@ -462,7 +467,7 @@ asm_boxed(lispobj* ptr, lispobj object, FILE* f) asm_label(ptr, object, f); - asm_header_word(ptr, object, f); + asm_header_word(ptr, object, f, ""); for (k = 1; k < len; ++k) { asm_lispobj(ptr + k, ptr[k], f); @@ -494,8 +499,10 @@ asm_list_pointer(lispobj* ptr, lispobj object, FILE* f) int asm_function_pointer(lispobj* ptr, lispobj object, FILE* f) { +#if 0 printf("function pointer 0x%lx\n", object); - +#endif + asm_label(ptr, object, f); asm_lispobj(ptr, object, f); return 1; @@ -515,7 +522,7 @@ asm_fdefn(lispobj* ptr, lispobj object, FILE* f) { asm_label(ptr, object, f); - asm_header_word(ptr, object, f); + asm_header_word(ptr, object, f, "fdefn"); asm_lispobj(ptr + 1, ptr[1], f); asm_lispobj(ptr + 2, ptr[2], f); @@ -541,7 +548,7 @@ asm_simple_vector(lispobj* ptr, lispobj object, FILE* f) lispobj* data = ptr + 2; asm_label(ptr, object, f); - asm_header_word(ptr, object, f); + asm_header_word(ptr, object, f, "simple vector"); asm_lispobj(ptr + 1, ptr[1], f); for (k = 0; k < len; ++k) { @@ -563,24 +570,277 @@ asm_complex_vector(lispobj* ptr, lispobj object, FILE* f) return asm_ni(ptr, object, f); } +int +asm_code_header(lispobj* ptr, lispobj object, FILE* f) +{ + struct code *code; + int nheader_words; + int ncode_words; + int nwords; + int k; + + code = (struct code *) ptr; + ncode_words = fixnum_value(code->code_size); + nheader_words = HeaderValue(object); + nwords = ncode_words + nheader_words; + nwords = CEILING(nwords, 2); + #if 0 + fprintf(stderr, "nwords = %d nheader_words %d\n", + nwords, nheader_words); +#endif + + asm_label(ptr, object, f); + asm_header_word(ptr, object, f, "code header"); + + for (k = 0; k < nheader_words - 1; ++k) { + asm_lispobj(ptr + k + 1, ptr[k + 1], f); + } + + fprintf(f, "# Code bytes?\n"); + + for (; k < nwords; ++k) { + fprintf(f, "\t.4byte\t0x%lx\n", ptr[k + 1]); + } + + return nwords; +} + int -asm_bignum(lispobj* ptr, lispobj object, FILE* f) +asm_simple_string(lispobj* where, lispobj object, FILE* f) { - int len = HeaderValue(object); + struct vector* vector; + int length; + int nwords; + int k; + int nchars; + uint16_t* s; + + /* + * NOTE: Strings contain one more byte of data than the length + * slot indicates. + */ + + vector = (struct vector *) where; + length = fixnum_value(vector->length) + 1; +#ifndef UNICODE +#ifdef __x86_64 + nwords = CEILING(NWORDS(length, 8) + 2, 2); +#else + nwords = CEILING(NWORDS(length, 4) + 2, 2); +#endif +#else + /* + * Strings are just like arrays with 16-bit elements, and contain + * one more element than the slot length indicates. + */ + nchars = CEILING(length + 1, 2); + nwords = CEILING(NWORDS(length, 2) + 2, 2); +#endif + + asm_label(where, object, f); + asm_header_word(where, object, f, "simple string"); + asm_lispobj(where + 1, where[1], f); + + s = (uint16_t*) vector->data; + + + for (k = 0; k < nchars; ++k) { + int c = s[k]; + + fprintf(f, "\t.2byte\t0x%x\t# ", c); + if (c >= ' ' && c <= 127) { + fprintf(f, "%c\n", c); + } else { + fprintf(f, "#\\u+%04x\n", c); + } + } + + return nwords; +} + +void +print_float(FILE* f, float value) +{ + if (isfinite(value)) { + fprintf(f, "\t.float\t%.15g\n", value); + } else { + union + { + uint32_t a; + float f; + } val; + + val.f = value; + fprintf(f, "\t.4byte\t0x%x\n", val.a); + } +} + +int +asm_single_float(lispobj* ptr, lispobj object, FILE* f) +{ + struct single_float* obj = (struct single_float*) ptr; asm_label(ptr, object, f); + asm_header_word(ptr, object, f, "single float"); + print_float(f, obj->value); - asm_lispobj(ptr, object, f); - ++ptr; + + return 2; +} + +void +print_double(FILE* f, double value) +{ + if (isfinite(value)) { + fprintf(f, "\t.double\t%.15g\n", value); + } else { + union + { + uint32_t a[2]; + double d; + } val; + + val.d = value; + + fprintf(f, "\t.4byte\t0x%x\n", val.a[0]); + fprintf(f, "\t.4byte\t0x%x\n", val.a[1]); + } +} + +int +asm_double_float(lispobj* ptr, lispobj object, FILE* f) +{ + struct double_float* obj = (struct double_float*) ptr; - for (k = 0; k < len; ++k) { - fprintf(f, "\t.4byte\t%d\n", ptr[k]); + asm_label(ptr, object, f); + asm_header_word(ptr, object, f, "double float"); + asm_lispobj(&obj->filler, obj->filler, f); + print_double(f, obj->value); + + return 4; +} + +int +asm_double_double_float(lispobj* ptr, lispobj object, FILE* f) +{ + struct double_double_float* obj = (struct double_double_float*) ptr; + + asm_label(ptr, object, f); + asm_header_word(ptr, object, f, "double double float"); + asm_lispobj(&obj->filler, obj->filler, f); + + print_double(f, obj->hi); + print_double(f, obj->lo); + + return 1 + HeaderValue(object); +} + +int +asm_complex_single_float(lispobj* ptr, lispobj object, FILE* f) +{ + struct complex_single_float* obj = (struct complex_single_float*) ptr; + + asm_label(ptr, object, f); + asm_header_word(ptr, object, f, "complex single-float"); + print_float(f, obj->real); + print_float(f, obj->imag); + /* Force double word boundary */ + asm_lispobj(ptr + 3, ptr[3], f); + + return CEILING(1 + HeaderValue(object), 2); +} + + +int +asm_vector_unsigned_byte_8(lispobj* ptr, lispobj object, FILE* f) +{ + struct vector *vector; + int length, nwords; + unsigned long* data; + int k; + + vector = (struct vector *) ptr; + length = fixnum_value(vector->length); +#ifdef __x86_64 + nwords = CEILING(NWORDS(length, 8) + 2, 2); +#else + nwords = CEILING(NWORDS(length, 4) + 2, 2); +#endif + asm_label(ptr, object, f); + asm_header_word(ptr, object, f, "vector unsigned_byte 8"); + asm_lispobj(ptr + 1, ptr[1], f); + + data = vector->data; + + /* Minus 2 for the header and length words */ + for (k = 0; k < nwords - 2; ++k) { + fprintf(f, "\t.4byte\t0x%lx\n", data[k]); + } + + return nwords; +} + +int +asm_vector_unsigned_byte_32(lispobj* ptr, lispobj object, FILE* f) +{ + struct vector *vector; + int length, nwords; + unsigned long* data; + int k; + + vector = (struct vector *) ptr; + length = fixnum_value(vector->length); +#ifdef __x86_64 + nwords = CEILING(NWORDS(length, 2) + 2, 2); +#else + nwords = CEILING(length + 2, 2); +#endif + + asm_label(ptr, object, f); + asm_header_word(ptr, object, f, "vector unsigned_byte 32"); + asm_lispobj(ptr + 1, ptr[1], f); + + data = vector->data; + + /* Minus 2 for the header and length words */ + for (k = 0; k < nwords - 2; ++k) { + fprintf(f, "\t.4byte\t0x%lx\n", data[k]); + } + + return nwords; +} + +int +asm_bignum(lispobj* ptr, lispobj object, FILE* f) +{ + int len = 1 + HeaderValue(object); + int k; + + len = CEILING(len, 2); + + asm_label(ptr, object, f); + asm_header_word(ptr, object, f, "bignum"); + + for (k = 1; k < len; ++k) { + fprintf(f, "\t.4byte\t0x%lx\t# %lu\n", ptr[k], ptr[k]); } return len; } +int +asm_sap(lispobj* ptr, lispobj object, FILE* f) +{ + asm_label(ptr, object, f); + asm_header_word(ptr, object, f, "sap"); + /* Just print out the raw value of the address */ + fprintf(f, "\t.4byte\t0x%lx\n", ptr[1]); + + return 2; +} + +#if 0 int asm_catch_block(lispobj* ptr, lispobj object, FILE* f) { @@ -674,19 +934,30 @@ init_asmtab(void) asmtab[type_OtherPointer | (k << 3)] = asm_other_pointer; } + asmtab[type_Bignum] = asm_bignum; asmtab[type_Ratio] = asm_boxed; + asmtab[type_SingleFloat] = asm_single_float; + asmtab[type_DoubleFloat] = asm_double_float; + asmtab[type_DoubleDoubleFloat] = asm_double_double_float; asmtab[type_Complex] = asm_boxed; + asmtab[type_ComplexSingleFloat] = asm_complex_single_float; asmtab[type_SimpleArray] = asm_boxed; - asmtab[type_SymbolHeader] = asm_boxed; - asmtab[type_Fdefn] = asm_fdefn; - asmtab[type_InstanceHeader] = asm_boxed; + asmtab[type_SimpleString] = asm_simple_string; asmtab[type_SimpleVector] = asm_simple_vector; - asmtab[type_FuncallableInstanceHeader] = asm_closure_header; + asmtab[type_SimpleArrayUnsignedByte8] = asm_vector_unsigned_byte_8; + asmtab[type_SimpleArrayUnsignedByte32] = asm_vector_unsigned_byte_32; + asmtab[type_ComplexString] = asm_boxed; asmtab[type_ComplexVector] = asm_boxed; - asmtab[type_BaseChar] = asm_immediate; + asmtab[type_CodeHeader] = asm_code_header; + asmtab[type_ClosureHeader] = asm_closure_header; + asmtab[type_FuncallableInstanceHeader] = asm_closure_header; /* Just use asm_boxed or have a special version for a value cell? */ asmtab[type_ValueCellHeader] = asm_boxed; - + asmtab[type_SymbolHeader] = asm_boxed; + asmtab[type_BaseChar] = asm_immediate; + asmtab[type_Sap] = asm_sap; + asmtab[type_InstanceHeader] = asm_boxed; + asmtab[type_Fdefn] = asm_fdefn; } void @@ -710,9 +981,9 @@ write_asm_object(const char *dir, int id, os_vm_address_t start, os_vm_address_t int k; /* Output the first word */ - asm_header_word(ptr, *ptr, f); + asm_header_word(ptr, *ptr, f, ""); /* Header word for NIL */ - asm_header_word(ptr + 1, ptr[1], f); + asm_header_word(ptr + 1, ptr[1], f, "NIL header"); /* Label for NIL */ asm_label(ptr + 2, ptr[2], f); ptr += 2; View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/02da09556ab426077f7262… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/02da09556ab426077f7262… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

cmucl-cvs