- cmucl-cvs - mailman3.common-lisp.net

[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

[Git][cmucl/cmucl][master] 2 commits: Fix #101: Add -ftrapping-math to clang compiler options
by Raymond Toy 05 Feb '21

05 Feb '21

Raymond Toy pushed to branch master at cmucl / cmucl Commits: 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 - - - - - 2 changed files: - .gitlab-ci.yml - src/lisp/Config.x86_linux_clang Changes: ===================================== .gitlab-ci.yml ===================================== @@ -7,6 +7,7 @@ stages: - install - build - test + - ansi-test - benchmark cache: @@ -41,7 +42,7 @@ linux:build: #- 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 "" -o snapshot/bin/lisp + - 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: @@ -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 View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/408711a94a60d6bb1422ed… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/408711a94a60d6bb1422ed… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl][issue-101-clang-trapping-math] Fix typo in linux:test:
by Raymond Toy 05 Feb '21

05 Feb '21

Raymond Toy pushed to branch issue-101-clang-trapping-math at cmucl / cmucl Commits: df93981a by Raymond Toy at 2021-02-04T20:51:20-08:00 Fix typo in linux:test: Forgot to remove the bit of code that runs the ansi-tests that was moved to a different stage. OSX is ok; I did it right there. - - - - - 1 changed file: - .gitlab-ci.yml Changes: ===================================== .gitlab-ci.yml ===================================== @@ -59,9 +59,6 @@ linux:test: artifacts: true 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:ansi-test: stage: ansi-test View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/commit/df93981a67fcbfa28037207… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/commit/df93981a67fcbfa28037207… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl][issue-101-clang-trapping-math] Split test phase into two
by Raymond Toy 05 Feb '21

05 Feb '21

Raymond Toy pushed to branch issue-101-clang-trapping-math at cmucl / cmucl Commits: 56ba2df2 by Raymond Toy at 2021-02-04T20:34:29-08:00 Split test phase into two Split the tests into two parts. One for our test suite (test) and one for the ansi-tests (ansi-test). - - - - - 1 changed file: - .gitlab-ci.yml Changes: ===================================== .gitlab-ci.yml ===================================== @@ -7,6 +7,7 @@ stages: - install - build - test + - ansi-test - benchmark cache: @@ -56,15 +57,31 @@ 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 + - cd ansi-test + - make LISP="../dist/bin/lisp -batch -noinit -nositeinit" + - grep 'No unexpected $successes\|failures$' test.out + +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: @@ -121,21 +138,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: View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/commit/56ba2df2b2843a647b7bba2… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/commit/56ba2df2b2843a647b7bba2… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl][issue-101-clang-trapping-math] Fix merge conflicts
by Raymond Toy 05 Feb '21

05 Feb '21

Raymond Toy pushed to branch issue-101-clang-trapping-math at cmucl / cmucl Commits: 5bd06ed3 by Raymond Toy at 2021-02-04T16:55:11-08:00 Fix merge conflicts - - - - - 1 changed file: - .gitlab-ci.yml Changes: ===================================== .gitlab-ci.yml ===================================== @@ -41,7 +41,7 @@ linux:build: #- 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 xtarget/lisp/lisp + - bin/build.sh $bootstrap -R -C "x86_linux_clang" -o snapshot/bin/lisp - bin/make-dist.sh -I dist linux-4 linux:test: View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/commit/5bd06ed3c9f9c20da4d071a… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/commit/5bd06ed3c9f9c20da4d071a… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl][issue-101-clang-trapping-math] 4 commits: Update CI to use 2021-01 snapshot
by Raymond Toy 05 Feb '21

05 Feb '21

Raymond Toy pushed to branch issue-101-clang-trapping-math 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 - - - - - 595c228e by Raymond Toy at 2021-02-04T16:53:07-08:00 Merge branch 'master' into issue-101-clang-trapping-math - - - - - 1 changed file: - .gitlab-ci.yml Changes: ===================================== .gitlab-ci.yml ===================================== @@ -1,6 +1,6 @@ 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: @@ -37,10 +37,10 @@ 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/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 xtarget/lisp/lisp - bin/make-dist.sh -I dist linux-4 @@ -108,11 +108,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: View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/d6a71026b4c40b708690c3… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/d6a71026b4c40b708690c3… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0