[Git][cmucl/cmucl][native-image] 17 commits: Update CI to use 2021-01 snapshot - cmucl-cvs - mailman3.common-lisp.net

6 Feb 2021


      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 &#39;update-ci-snapshot-2021-01&#39; into &#39;master&#39;
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 &#39;issue-101-clang-trapping-math&#39; into &#39;master&#39;
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 &#39;master&#39; 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/02da09556ab426077f72625...
-- 
View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/02da09556ab426077f72625...
You're receiving this email because of your account on gitlab.common-lisp.net.





    