[Sbcl-devel] Patch: visible versions in platform-table.html

[Kevin Reid <kpreid@at...>]

This patch adds visible version numbers to the platform table binary  
download links.

It attempts to change as little as possible while adding this  
feature; an obvious improvement would be to add a separate version  
field rather than heuristically extracting it from the download link.

[Sbcl-devel] Re: [PATCH] NetBSD/ppc (not fully working yet)

[Richard M Kreuter <kreuter@pr...>]

Write-O.

Richard M Kreuter <kreuter@...> writes:

> * Executables on NetBSD/ppc get mapped by default where we want the
>   static-space, so I added a linker script to move the runtime out of
    ^^^^^^^^^^^^
    read-only-space

[Sbcl-devel] [PATCH] NetBSD/ppc (not fully working yet)

[Richard M Kreuter <kreuter@pr...>]

Howdy,

Folks on #lisp encouraged me to post the patch below, though the port
isn't working fully.

I don't intend for the patch to be committed, though I'm able to build
a working SBCL with this code on both NetBSD/x86 and Linux/ppc (though
there are other problems on each of those two platforms).

There are a few problems I know about: 

(1) I can't get %alien-funcall to work properly for a C function that
    takes a 64-bit argument and returns a 64-bit value.  Here's what
    happens when I tried compiling unix-lseek (off_t is a 64-bit
    quantity on NetBSD):

| ; compiling (DEFUN UNIX-LSEEK ...)
| debugger invoked on a SIMPLE-ERROR:
|   #<SB!C:TN t1[NL0]> is wired to a location that it conflicts with.
| 
| Type HELP for debugger help, or (SB-EXT:QUIT) to exit from SBCL.
| 
| restarts (invokable by number or by possibly-abbreviated name):
|   0: [ABORT] Exit debugger, returning to top level.
| 
| (SB!C::PACK-WIRED-TN #<SB!C:TN t1[NL0]> T)

(1.5) In order to get further along, I lie about the size lseek's
    return value in unix.lisp (AFAICT, the first place where
    unix-lseek gets called during warm-init, it's just setting the
    file-position to zero, so this change shouldn't break that).  I'll
    undo this once %alien-funcall is working properly.

(2) After all that, warm-init stops just after the first in-package
    form in the first file it tries to compile:

| ; compiling file "/home/kreuter/lsp/imp/sbcl-netbsd-ppc/src/pcl/early-low.lisp" (written 21 OCT 2005 07:54:02 PM):
| ; compiling (IN-PACKAGE "SB-PCL")
| debugger invoked on a TYPE-ERROR:
|   #S(TYPE-ERROR
|      :ACTUAL-INITARGS (DATUM -2935
|                              EXPECTED-TYPE
|                              (OR UNSIGNED-BYTE (MEMBER NIL T)))
|      :ASSIGNED-SLOTS NIL)

    I don't have any idea what's going wrong here, but I tried
    watching this under a syscall tracer, and it didn't look like this
    happened after an lseek, so I don't think my hackaround for that
    is the culprit.

(3) With sb-show enabled, the error I just described causes a cascade
    of errors until the runtime gives up.  I can supply a (3.2MB)
    transcript of make-host-2.sh with sb-show enabled, if anybody
    wants to see it.

Can anybody straighten me out on any of these?

Otherwise, there are a couple things worth mentioning:

* I added some comments in places where I didn't change any code,
  which I'll remove before submitting a patch for inclusion.

* Executables on NetBSD/ppc get mapped by default where we want the
  static-space, so I added a linker script to move the runtime out of
  the way.  I only made a tiny change to the default script.  Do I
  need to do anything special to make the linker script at all
  future-proof?

* In the incalculably improbable circumstance that somebody reading
  this wants to try running SBCL on NetBSD/ppc, you'll need a NetBSD
  that saves the DAR in mcontext for GC triggering to work.  I believe
  I have a patch that does this, but I don't yet know if it works: I
  was hoping to use the SBCL runtime to determine this, but I haven't
  gotten far enough along for a GC to be triggered.  Anyhow, if you
  want this patch, let me know (you will have to rebuild your kernel
  and userland after applying it, though).

Thanks,
RmK

diff -purN -xCVS -x'*.d' -xcustomize-target-features.lisp sbcl/src/code/host-alieneval.lisp sbcl-netbsd-ppc/src/code/host-alieneval.lisp
--- sbcl/src/code/host-alieneval.lisp	2005-11-04 08:32:46.000000000 -0500
+++ sbcl-netbsd-ppc/src/code/host-alieneval.lisp	2005-11-13 20:50:04.000000000 -0500
@@ -22,6 +22,10 @@
 
 (defun guess-alignment (bits)
   (cond ((null bits) nil)
+	;; The ppc/darwin alignment here may be for the PowerOpen ABI;
+	;; anyhow it seems consistent with number-stack-displacement
+	;; in src/compiler/ppc. RMK, guessing about uncommented
+	;; obscurities.
         #!-(or x86 (and ppc darwin)) ((> bits 32) 64)
         ((> bits 16) 32)
         ((> bits 8) 16)
diff -purN -xCVS -x'*.d' -xcustomize-target-features.lisp sbcl/src/code/unix.lisp sbcl-netbsd-ppc/src/code/unix.lisp
--- sbcl/src/code/unix.lisp	2005-10-12 11:12:17.000000000 -0400
+++ sbcl-netbsd-ppc/src/code/unix.lisp	2005-12-10 20:49:56.000000000 -0500
@@ -237,9 +237,17 @@ SYSCALL-FORM. Repeat evaluation of SYSCA
   "
   (declare (type unix-fd fd)
            (type (integer 0 2) whence))
-  (let ((result (alien-funcall (extern-alien "lseek" (function off-t int off-t int))
+  (let ((result (alien-funcall (extern-alien "lseek"
+					     ;; I (RMK) can't make
+					     ;; %alien-funcall like
+					     ;; this alien function on
+					     ;; netbsd/ppc
+					     #!-(and netbsd ppc)
+					     (function off-t int off-t int)
+			                     #!+(and netbsd ppc)
+					     (function int int off-t int))
                  fd offset whence)))
-    (if (minusp result )
+    (if (minusp result)
         (values nil (get-errno))
       (values result 0))))
 
diff -purN -xCVS -x'*.d' -xcustomize-target-features.lisp sbcl/src/compiler/ppc/c-call.lisp sbcl-netbsd-ppc/src/compiler/ppc/c-call.lisp
--- sbcl/src/compiler/ppc/c-call.lisp	2005-11-06 08:25:50.000000000 -0500
+++ sbcl-netbsd-ppc/src/compiler/ppc/c-call.lisp	2005-12-10 19:12:35.000000000 -0500
@@ -238,7 +238,7 @@
                (alien-fun-type-result-type type)
                #!+darwin (make-result-state))))))
 
-#!+darwin
+#!+(or darwin netbsd)
 (deftransform %alien-funcall ((function type &rest args))
   (aver (sb!c::constant-lvar-p type))
   (let* ((type (sb!c::lvar-value type))
@@ -262,6 +262,15 @@
                             ;; 64-bit long long types are stored in
                             ;; consecutive locations, most significant word
                             ;; first (big-endian).
+			    ;; On NetBSD, 64-bit quantities seem to
+			    ;; need start in registers NLx, where x is
+			    ;; even. -- RMK 20051129
+			    #!+netbsd
+			    (when (oddp (length (new-args)))
+			      (new-args 0)
+			      (new-arg-types
+			       (parse-alien-type '(unsigned 32)
+						 (sb!kernel:make-null-lexenv))))
                             (new-args `(ash ,arg -32))
                             (new-args `(logand ,arg #xffffffff))
                             (if (alien-integer-type-signed type)
diff -purN -xCVS -x'*.d' -xcustomize-target-features.lisp sbcl/src/compiler/ppc/parms.lisp sbcl-netbsd-ppc/src/compiler/ppc/parms.lisp
--- sbcl/src/compiler/ppc/parms.lisp	2005-08-18 06:06:32.000000000 -0400
+++ sbcl-netbsd-ppc/src/compiler/ppc/parms.lisp	2005-12-10 19:32:45.000000000 -0500
@@ -108,6 +108,13 @@
   (def!constant linkage-table-space-start #x0a000000)
   (def!constant linkage-table-space-end   #x0b000000)
   (def!constant linkage-table-entry-size 16))
+
+#!+netbsd
+(progn
+  (def!constant dynamic-0-space-start #x20000000)
+  (def!constant dynamic-0-space-end   #x3ffff000)
+  (def!constant dynamic-1-space-start #x50000000)
+  (def!constant dynamic-1-space-end   #x6ffff000))
 
 ;;;; Other miscellaneous constants.
 
diff -purN -xCVS -x'*.d' -xcustomize-target-features.lisp sbcl/src/compiler/ppc/vm.lisp sbcl-netbsd-ppc/src/compiler/ppc/vm.lisp
--- sbcl/src/compiler/ppc/vm.lisp	2005-07-14 14:48:33.000000000 -0400
+++ sbcl-netbsd-ppc/src/compiler/ppc/vm.lisp	2005-12-11 00:25:12.000000000 -0500
@@ -52,12 +52,19 @@
   (defreg fdefn 10)                     ; was nl7
   (defreg nargs 11)
   ;; FIXME: some kind of comment here would be nice.
+  ;; Okay! NetBSD's trapframe constructor (in
+  ;; sys/arch/powerpc/powerpc/trap.c) stores the frame pointer in the
+  ;; 13th register slot in the frame struct, which will get stored in
+  ;; the 13th register slot in uc_mcontext, so that's where we need to
+  ;; look for reg_NFP.  Perhaps that's what's going on in Darwin, too.
+  ;; (This comment also applies to the contents of
+  ;; src/runtime/ppc-lispregs.h.)  -- RMK, 20051029 
   ;;
   ;; FIXME II: this also reveals the need to autogenerate lispregs.h
-  #!+darwin  (defreg cfunc 12)
-  #!-darwin  (defreg nfp 12)
-  #!+darwin  (defreg nfp 13)
-  #!-darwin  (defreg cfunc 13)
+  #!+(or darwin netbsd) (defreg cfunc 12)
+  #!-(or darwin netbsd) (defreg nfp 12)
+  #!+(or darwin netbsd) (defreg nfp 13)
+  #!-(or darwin netbsd) (defreg cfunc 13)
   (defreg bsp 14)
   (defreg cfp 15)
   (defreg csp 16)
diff -purN -xCVS -x'*.d' -xcustomize-target-features.lisp sbcl/src/runtime/Config.ppc-netbsd sbcl-netbsd-ppc/src/runtime/Config.ppc-netbsd
--- sbcl/src/runtime/Config.ppc-netbsd	1969-12-31 19:00:00.000000000 -0500
+++ sbcl-netbsd-ppc/src/runtime/Config.ppc-netbsd	2005-12-10 19:41:10.000000000 -0500
@@ -0,0 +1,25 @@
+# -*- makefile -*- for the C-level run-time support for SBCL
+
+# This software is part of the SBCL system. See the README file for
+# more information.
+#
+# This software is derived from the CMU CL system, which was
+# written at Carnegie Mellon University and released into the
+# public domain. The software is in the public domain and is
+# provided with absolutely no warranty. See the COPYING and CREDITS
+# files for more information.
+
+CFLAGS = -g
+
+LINKFLAGS += -dynamic -export-dynamic -Wl,--script=ld-script.ppc-netbsd
+
+ASSEM_SRC = ppc-assem.S ldso-stubs.S
+ARCH_SRC = ppc-arch.c
+
+OS_SRC = bsd-os.c ppc-bsd-os.c undefineds.c
+
+GC_SRC = cheneygc.c
+
+# Nothing to do for after-grovel-headers.
+.PHONY: after-grovel-headers
+after-grovel-headers:
diff -purN -xCVS -x'*.d' -xcustomize-target-features.lisp sbcl/src/runtime/bsd-os.c sbcl-netbsd-ppc/src/runtime/bsd-os.c
--- sbcl/src/runtime/bsd-os.c	2005-12-04 17:25:07.000000000 -0500
+++ sbcl-netbsd-ppc/src/runtime/bsd-os.c	2005-12-10 19:34:22.000000000 -0500
@@ -61,6 +61,9 @@ os_init(char *argv[], char *envp[])
 #endif /* __NetBSD__ */
 }
 
+/* If this port to NetBSD/macppc works out, this
+   should probably move to x86-bsd-os.c. RMK 20051021 */
+#ifdef LISP_FEATURE_X86
 int *os_context_pc_addr(os_context_t *context)
 {
 #if defined __FreeBSD__
@@ -75,6 +78,7 @@ int *os_context_pc_addr(os_context_t *co
 #error unsupported BSD variant
 #endif
 }
+#endif /* LISP_FEATURE_X86 */
 
 sigset_t *
 os_context_sigmask_addr(os_context_t *context)
@@ -185,9 +189,9 @@ memory_fault_handler(int signal, siginfo
     void *fault_addr = siginfo->si_addr;
 #elif defined LISP_FEATURE_DARWIN
     void *fault_addr = siginfo->si_addr;
-#else
+#else 
 #error unsupported BSD variant
-#endif
+#endif /* __*BSD__ */
 
     os_context_t *context = arch_os_get_context(&void_context);
     if (!gencgc_handle_wp_violation(fault_addr))
@@ -196,7 +200,7 @@ memory_fault_handler(int signal, siginfo
             arrange_return_to_lisp_function(context, SymbolFunction(MEMORY_FAULT_ERROR));
 #else
             interrupt_handle_now(signal, siginfo, context);
-#endif
+#endif /* C_STACK */
 }
 void
 os_install_interrupt_handlers(void)
@@ -207,7 +211,7 @@ os_install_interrupt_handlers(void)
     SHOW("leaving os_install_interrupt_handlers()");
 }
 
-#else /* Currently Darwin only */
+#else /* LISP_FEATURE_GENGC, Currently Darwin only */
 
 static void
 sigsegv_handler(int signal, siginfo_t *info, void* void_context)
@@ -221,7 +225,9 @@ sigsegv_handler(int signal, siginfo_t *i
         if(!handle_guard_page_triggered(context,addr))
             interrupt_handle_now(signal, info, context);
     /* Work around G5 bug; fix courtesy gbyers */
+#ifdef LISP_FEATURE_DARWIN
     DARWIN_FIX_CONTEXT(context);
+#endif
 }
 
 void
diff -purN -xCVS -x'*.d' -xcustomize-target-features.lisp sbcl/src/runtime/ld-script.ppc-netbsd sbcl-netbsd-ppc/src/runtime/ld-script.ppc-netbsd
--- sbcl/src/runtime/ld-script.ppc-netbsd	1969-12-31 19:00:00.000000000 -0500
+++ sbcl-netbsd-ppc/src/runtime/ld-script.ppc-netbsd	2005-11-07 21:49:49.000000000 -0500
@@ -0,0 +1,213 @@
+/* Script for -z combreloc: combine and sort reloc sections */
+OUTPUT_FORMAT("elf32-powerpc", "elf32-powerpc",
+	      "elf32-powerpc")
+OUTPUT_ARCH(powerpc:common)
+ENTRY(_start)
+SEARCH_DIR("/usr/powerpc--netbsd/lib"); SEARCH_DIR("/usr/lib");
+/* Do we need any of these for elf?
+   __DYNAMIC = 0;    */
+PROVIDE (__stack = 0); PROVIDE (___stack = 0);
+SECTIONS
+{
+  /* Read-only sections, merged into text segment: */
+  PROVIDE (__executable_start = 0x05000000); . = 0x05000000 + SIZEOF_HEADERS;
+  .interp         : { *(.interp) }
+  .hash           : { *(.hash) }
+  .dynsym         : { *(.dynsym) }
+  .dynstr         : { *(.dynstr) }
+  .gnu.version    : { *(.gnu.version) }
+  .gnu.version_d  : { *(.gnu.version_d) }
+  .gnu.version_r  : { *(.gnu.version_r) }
+  .rel.dyn        :
+    {
+      *(.rel.init)
+      *(.rel.text .rel.text.* .rel.gnu.linkonce.t.*)
+      *(.rel.fini)
+      *(.rel.rodata .rel.rodata.* .rel.gnu.linkonce.r.*)
+      *(.rel.data .rel.data.* .rel.gnu.linkonce.d.*)
+      *(.rel.tdata .rel.tdata.* .rel.gnu.linkonce.td.*)
+      *(.rel.tbss .rel.tbss.* .rel.gnu.linkonce.tb.*)
+      *(.rel.ctors)
+      *(.rel.dtors)
+      *(.rel.got)
+      *(.rel.sdata .rel.sdata.* .rel.gnu.linkonce.s.*)
+      *(.rel.sbss .rel.sbss.* .rel.gnu.linkonce.sb.*)
+      *(.rel.sdata2 .rel.sdata2.* .rel.gnu.linkonce.s2.*)
+      *(.rel.sbss2 .rel.sbss2.* .rel.gnu.linkonce.sb2.*)
+      *(.rel.bss .rel.bss.* .rel.gnu.linkonce.b.*)
+    }
+  .rela.dyn       :
+    {
+      *(.rela.init)
+      *(.rela.text .rela.text.* .rela.gnu.linkonce.t.*)
+      *(.rela.fini)
+      *(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*)
+      *(.rela.data .rela.data.* .rela.gnu.linkonce.d.*)
+      *(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*)
+      *(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*)
+      *(.rela.ctors)
+      *(.rela.dtors)
+      *(.rela.got)
+      *(.rela.got1)
+      *(.rela.got2)
+      *(.rela.sdata .rela.sdata.* .rela.gnu.linkonce.s.*)
+      *(.rela.sbss .rela.sbss.* .rela.gnu.linkonce.sb.*)
+      *(.rela.sdata2 .rela.sdata2.* .rela.gnu.linkonce.s2.*)
+      *(.rela.sbss2 .rela.sbss2.* .rela.gnu.linkonce.sb2.*)
+      *(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*)
+    }
+  .rel.plt        : { *(.rel.plt) }
+  .rela.plt       : { *(.rela.plt) }
+  .init           :
+  {
+    KEEP (*(.init))
+  } =0
+  .text           :
+  {
+    *(.text .stub .text.* .gnu.linkonce.t.*)
+    /* .gnu.warning sections are handled specially by elf32.em.  */
+    *(.gnu.warning)
+  } =0
+  .fini           :
+  {
+    KEEP (*(.fini))
+  } =0
+  PROVIDE (__etext = .);
+  PROVIDE (_etext = .);
+  PROVIDE (etext = .);
+  .rodata         : { *(.rodata .rodata.* .gnu.linkonce.r.*) }
+  .rodata1        : { *(.rodata1) }
+  .sdata2         : { *(.sdata2 .sdata2.* .gnu.linkonce.s2.*) }
+  .sbss2          : { *(.sbss2 .sbss2.* .gnu.linkonce.sb2.*) }
+  .eh_frame_hdr : { *(.eh_frame_hdr) }
+  /* Adjust the address for the data segment.  We want to adjust up to
+     the same address within the page on the next page up.  */
+  . = ALIGN (0x10000) - ((0x10000 - .) & (0x10000 - 1)); . = DATA_SEGMENT_ALIGN (0x10000, 0x1000);
+  /* Ensure the __preinit_array_start label is properly aligned.  We
+     could instead move the label definition inside the section, but
+     the linker would then create the section even if it turns out to
+     be empty, which isn't pretty.  */
+  . = ALIGN(32 / 8);
+  PROVIDE (__preinit_array_start = .);
+  .preinit_array     : { *(.preinit_array) }
+  PROVIDE (__preinit_array_end = .);
+  PROVIDE (__init_array_start = .);
+  .init_array     : { *(.init_array) }
+  PROVIDE (__init_array_end = .);
+  PROVIDE (__fini_array_start = .);
+  .fini_array     : { *(.fini_array) }
+  PROVIDE (__fini_array_end = .);
+  .data           :
+  {
+    *(.data .data.* .gnu.linkonce.d.*)
+    SORT(CONSTRUCTORS)
+  }
+  .data1          : { *(.data1) }
+  .tdata	  : { *(.tdata .tdata.* .gnu.linkonce.td.*) }
+  .tbss		  : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) }
+  .eh_frame       : { KEEP (*(.eh_frame)) }
+  .gcc_except_table   : { *(.gcc_except_table) }
+  .fixup          : { *(.fixup) }
+  .got1           : { *(.got1) }
+  .got2           : { *(.got2) }
+  .dynamic        : { *(.dynamic) }
+  .ctors          :
+  {
+    /* gcc uses crtbegin.o to find the start of
+       the constructors, so we make sure it is
+       first.  Because this is a wildcard, it
+       doesn't matter if the user does not
+       actually link against crtbegin.o; the
+       linker won't look for a file to match a
+       wildcard.  The wildcard also means that it
+       doesn't matter which directory crtbegin.o
+       is in.  */
+    KEEP (*crtbegin*.o(.ctors))
+    /* We don't want to include the .ctor section from
+       from the crtend.o file until after the sorted ctors.
+       The .ctor section from the crtend file contains the
+       end of ctors marker and it must be last */
+    KEEP (*(EXCLUDE_FILE (*crtend*.o ) .ctors))
+    KEEP (*(SORT(.ctors.*)))
+    KEEP (*(.ctors))
+  }
+  .dtors          :
+  {
+    KEEP (*crtbegin*.o(.dtors))
+    KEEP (*(EXCLUDE_FILE (*crtend*.o ) .dtors))
+    KEEP (*(SORT(.dtors.*)))
+    KEEP (*(.dtors))
+  }
+  .jcr            : { KEEP (*(.jcr)) }
+  .got            : { *(.got.plt) *(.got) }
+  /* We want the small data sections together, so single-instruction offsets
+     can access them all, and initialized data all before uninitialized, so
+     we can shorten the on-disk segment size.  */
+  .sdata          :
+  {
+    *(.sdata .sdata.* .gnu.linkonce.s.*)
+  }
+  _edata = .;
+  PROVIDE (edata = .);
+  __bss_start = .;
+  .sbss           :
+  {
+    PROVIDE (__sbss_start = .);
+    PROVIDE (___sbss_start = .);
+    *(.dynsbss)
+    *(.sbss .sbss.* .gnu.linkonce.sb.*)
+    *(.scommon)
+    PROVIDE (__sbss_end = .);
+    PROVIDE (___sbss_end = .);
+  }
+  .plt            : { *(.plt) }
+  .bss            :
+  {
+   *(.dynbss)
+   *(.bss .bss.* .gnu.linkonce.b.*)
+   *(COMMON)
+   /* Align here to ensure that the .bss section occupies space up to
+      _end.  Align after .bss to ensure correct alignment even if the
+      .bss section disappears because there are no input sections.  */
+   . = ALIGN(32 / 8);
+  }
+  . = ALIGN(32 / 8);
+  _end = .;
+  __end = .;
+  PROVIDE (end = .);
+  . = DATA_SEGMENT_END (.);
+  /* Stabs debugging sections.  */
+  .stab          0 : { *(.stab) }
+  .stabstr       0 : { *(.stabstr) }
+  .stab.excl     0 : { *(.stab.excl) }
+  .stab.exclstr  0 : { *(.stab.exclstr) }
+  .stab.index    0 : { *(.stab.index) }
+  .stab.indexstr 0 : { *(.stab.indexstr) }
+  .comment       0 : { *(.comment) }
+  /* DWARF debug sections.
+     Symbols in the DWARF debugging sections are relative to the beginning
+     of the section so we begin them at 0.  */
+  /* DWARF 1 */
+  .debug          0 : { *(.debug) }
+  .line           0 : { *(.line) }
+  /* GNU DWARF 1 extensions */
+  .debug_srcinfo  0 : { *(.debug_srcinfo) }
+  .debug_sfnames  0 : { *(.debug_sfnames) }
+  /* DWARF 1.1 and DWARF 2 */
+  .debug_aranges  0 : { *(.debug_aranges) }
+  .debug_pubnames 0 : { *(.debug_pubnames) }
+  /* DWARF 2 */
+  .debug_info     0 : { *(.debug_info .gnu.linkonce.wi.*) }
+  .debug_abbrev   0 : { *(.debug_abbrev) }
+  .debug_line     0 : { *(.debug_line) }
+  .debug_frame    0 : { *(.debug_frame) }
+  .debug_str      0 : { *(.debug_str) }
+  .debug_loc      0 : { *(.debug_loc) }
+  .debug_macinfo  0 : { *(.debug_macinfo) }
+  /* SGI/MIPS DWARF 2 extensions */
+  .debug_weaknames 0 : { *(.debug_weaknames) }
+  .debug_funcnames 0 : { *(.debug_funcnames) }
+  .debug_typenames 0 : { *(.debug_typenames) }
+  .debug_varnames  0 : { *(.debug_varnames) }
+  /DISCARD/ : { *(.note.GNU-stack) }
+}
diff -purN -xCVS -x'*.d' -xcustomize-target-features.lisp sbcl/src/runtime/ldso-stubs.S sbcl-netbsd-ppc/src/runtime/ldso-stubs.S
--- sbcl/src/runtime/ldso-stubs.S	1969-12-31 19:00:00.000000000 -0500
+++ sbcl-netbsd-ppc/src/runtime/ldso-stubs.S	2005-12-11 01:09:32.000000000 -0500
@@ -0,0 +1,131 @@
+
+/* This is an automatically generated file, please do not hand-edit it.
+ * See the program tools-for-build/ldso-stubs.lisp. */
+
+#ifndef LANGUAGE_ASSEMBLY
+#define LANGUAGE_ASSEMBLY
+#endif
+#include "sbcl.h"
+
+#define LDSO_STUBIFY(fct)                       \
+.globl ldso_stub__ ## fct ;                     \
+        .type    ldso_stub__ ## fct,@function ; \
+ldso_stub__ ## fct: ;                           \
+        b fct ;                                 \
+.L ## fct ## e1: ;                              \
+        .size    ldso_stub__ ## fct,.L ## fct ## e1-ldso_stub__ ## fct ;
+LDSO_STUBIFY(accept)
+LDSO_STUBIFY(access)
+LDSO_STUBIFY(acos)
+LDSO_STUBIFY(acosh)
+LDSO_STUBIFY(asin)
+LDSO_STUBIFY(asinh)
+LDSO_STUBIFY(atanh)
+LDSO_STUBIFY(bind)
+LDSO_STUBIFY(cfgetispeed)
+LDSO_STUBIFY(cfgetospeed)
+LDSO_STUBIFY(cfsetispeed)
+LDSO_STUBIFY(cfsetospeed)
+LDSO_STUBIFY(chmod)
+LDSO_STUBIFY(chown)
+LDSO_STUBIFY(close)
+LDSO_STUBIFY(closedir)
+LDSO_STUBIFY(connect)
+LDSO_STUBIFY(cosh)
+LDSO_STUBIFY(creat)
+LDSO_STUBIFY(dup)
+LDSO_STUBIFY(dup2)
+LDSO_STUBIFY(execve)
+LDSO_STUBIFY(exit)
+LDSO_STUBIFY(fchmod)
+LDSO_STUBIFY(fchown)
+LDSO_STUBIFY(fcntl)
+LDSO_STUBIFY(fork)
+LDSO_STUBIFY(free)
+LDSO_STUBIFY(fstat)
+LDSO_STUBIFY(fsync)
+LDSO_STUBIFY(ftruncate)
+LDSO_STUBIFY(getcwd)
+LDSO_STUBIFY(getdtablesize)
+LDSO_STUBIFY(getegid)
+LDSO_STUBIFY(getenv)
+LDSO_STUBIFY(getgid)
+LDSO_STUBIFY(gethostbyaddr)
+LDSO_STUBIFY(gethostbyname)
+LDSO_STUBIFY(gethostname)
+LDSO_STUBIFY(getitimer)
+LDSO_STUBIFY(getpagesize)
+LDSO_STUBIFY(getpeername)
+LDSO_STUBIFY(getpgrp)
+LDSO_STUBIFY(getpid)
+LDSO_STUBIFY(getppid)
+LDSO_STUBIFY(getrusage)
+LDSO_STUBIFY(getsockname)
+LDSO_STUBIFY(gettimeofday)
+LDSO_STUBIFY(getuid)
+LDSO_STUBIFY(hypot)
+LDSO_STUBIFY(ioctl)
+LDSO_STUBIFY(isatty)
+LDSO_STUBIFY(kill)
+LDSO_STUBIFY(killpg)
+LDSO_STUBIFY(link)
+LDSO_STUBIFY(listen)
+LDSO_STUBIFY(log1p)
+LDSO_STUBIFY(lseek)
+LDSO_STUBIFY(lstat)
+LDSO_STUBIFY(malloc)
+LDSO_STUBIFY(memmove)
+LDSO_STUBIFY(mkdir)
+LDSO_STUBIFY(nanosleep)
+LDSO_STUBIFY(nl_langinfo)
+LDSO_STUBIFY(open)
+LDSO_STUBIFY(opendir)
+LDSO_STUBIFY(pipe)
+LDSO_STUBIFY(pow)
+LDSO_STUBIFY(read)
+LDSO_STUBIFY(readdir)
+LDSO_STUBIFY(readlink)
+LDSO_STUBIFY(recv)
+LDSO_STUBIFY(rename)
+LDSO_STUBIFY(rmdir)
+LDSO_STUBIFY(select)
+LDSO_STUBIFY(send)
+LDSO_STUBIFY(setitimer)
+LDSO_STUBIFY(setpgrp)
+LDSO_STUBIFY(setsid)
+LDSO_STUBIFY(sinh)
+LDSO_STUBIFY(socket)
+LDSO_STUBIFY(stat)
+LDSO_STUBIFY(strerror)
+LDSO_STUBIFY(strlen)
+LDSO_STUBIFY(symlink)
+LDSO_STUBIFY(sync)
+LDSO_STUBIFY(tanh)
+LDSO_STUBIFY(tcdrain)
+LDSO_STUBIFY(tcflow)
+LDSO_STUBIFY(tcflush)
+LDSO_STUBIFY(tcgetattr)
+LDSO_STUBIFY(tcsendbreak)
+LDSO_STUBIFY(tcsetattr)
+LDSO_STUBIFY(truncate)
+LDSO_STUBIFY(ttyname)
+LDSO_STUBIFY(tzname)
+LDSO_STUBIFY(unlink)
+LDSO_STUBIFY(utimes)
+LDSO_STUBIFY(wait3)
+LDSO_STUBIFY(write)
+LDSO_STUBIFY(sin)
+LDSO_STUBIFY(cos)
+LDSO_STUBIFY(tan)
+LDSO_STUBIFY(atan)
+LDSO_STUBIFY(atan2)
+LDSO_STUBIFY(exp)
+LDSO_STUBIFY(log)
+LDSO_STUBIFY(log10)
+LDSO_STUBIFY(sqrt)
+LDSO_STUBIFY(dlclose)
+LDSO_STUBIFY(dlerror)
+LDSO_STUBIFY(dlopen)
+LDSO_STUBIFY(dlsym)
+LDSO_STUBIFY(dladdr)
+LDSO_STUBIFY(sigsetmask)
diff -purN -xCVS -x'*.d' -xcustomize-target-features.lisp sbcl/src/runtime/monitor.c sbcl-netbsd-ppc/src/runtime/monitor.c
--- sbcl/src/runtime/monitor.c	2005-10-27 17:22:42.000000000 -0400
+++ sbcl-netbsd-ppc/src/runtime/monitor.c	2005-12-10 19:36:48.000000000 -0500
@@ -341,7 +341,7 @@ print_context(os_context_t *context)
         brief_print((lispobj)(*os_context_register_addr(context,i)));
 #endif
     }
-#ifdef LISP_FEATURE_DARWIN
+#if defined(LISP_FEATURE_DARWIN) || defined(LISP_FEATURE_NETBSD)
     printf("DAR:\t\t 0x%08lx\n", (unsigned long)(*os_context_register_addr(context, 41)));
     printf("DSISR:\t\t 0x%08lx\n", (unsigned long)(*os_context_register_addr(context, 42)));
 #endif
diff -purN -xCVS -x'*.d' -xcustomize-target-features.lisp sbcl/src/runtime/ppc-assem.S sbcl-netbsd-ppc/src/runtime/ppc-assem.S
--- sbcl/src/runtime/ppc-assem.S	2005-12-10 23:40:02.000000000 -0500
+++ sbcl-netbsd-ppc/src/runtime/ppc-assem.S	2005-12-11 01:43:58.000000000 -0500
@@ -56,12 +56,15 @@ x:
 #endif
 	
 #define	FIRST_SAVE_FPR	14	/* lowest-numbered non-volatile FPR */
-#ifdef LISP_FEATURE_DARWIN
+#if defined LISP_FEATURE_DARWIN || defined LISP_FEATURE_NETBSD
 #define	FIRST_SAVE_GPR	13	/* lowest-numbered non-volatile GPR */
+#else
+#define	FIRST_SAVE_GPR	14	/* lowest-numbered non-volatile GPR */
+#endif
+#ifdef LISP_FEATURE_DARWIN
 #define NGPR_SAVE_BYTES(n) ((32-(n))*4)
 #define FRAME_ARG_BYTES(n)  (((((n)+6)*4)+15)&~15)
 #else
-#define	FIRST_SAVE_GPR	14	/* lowest-numbered non-volatile GPR */
 #define NGPR_SAVE_BYTES(n) ((32-(~1&((n)+1)))*4)
 #define FRAME_ARG_BYTES(n)  (((((n)+2)*4)+15)&~15)
 #endif
diff -purN -xCVS -x'*.d' -xcustomize-target-features.lisp sbcl/src/runtime/ppc-bsd-os.c sbcl-netbsd-ppc/src/runtime/ppc-bsd-os.c
--- sbcl/src/runtime/ppc-bsd-os.c	1969-12-31 19:00:00.000000000 -0500
+++ sbcl-netbsd-ppc/src/runtime/ppc-bsd-os.c	2005-12-10 19:49:13.000000000 -0500
@@ -0,0 +1,109 @@
+/*
+ * This is the PowerPC/BSD incarnation of arch-dependent OS-dependent
+ * routines.  Cribbed from ppc-darwin-os.c and ppc-linux-os.c.
+ */
+
+/*
+ * This software is part of the SBCL system. See the README file for
+ * more information.
+ *
+ * This software is derived from the CMU CL system, which was
+ * written at Carnegie Mellon University and released into the
+ * public domain. The software is in the public domain and is
+ * provided with absolutely no warranty. See the COPYING and CREDITS
+ * files for more information.
+ */
+
+#include "sbcl.h"
+#include "globals.h"
+#include <signal.h>
+#include <ucontext.h>
+#include "bsd-os.h"
+
+size_t os_vm_page_size;
+
+os_context_register_t   *
+os_context_register_addr(os_context_t *context, int offset)
+{
+#ifdef __NetBSD__
+  switch (offset) {
+  case 42: /* PT_DAR */
+    return &((context->uc_mcontext.__gregs)[_REG_DSISR]);
+  case 41: /* PT_DSISR */
+    return &((context->uc_mcontext.__gregs)[_REG_DAR]);
+  /* Judging from this function's definition in ppc-darwin-os.c, only
+     the gp registers and DAR/DSISR are used.  The gp registers are
+     located where you'd expect them to be in uc_mcontext. */
+  default:
+    return &((context->uc_mcontext.__gregs)[offset]);
+  }
+#else
+#error unsupported BSD variant
+#endif
+}
+
+os_context_register_t *
+os_context_pc_addr(os_context_t *context)
+{
+#ifdef __NetBSD__
+    return &((context->uc_mcontext.__gregs)[_REG_PC]);
+#else
+#error unsupported BSD variant
+#endif
+}
+
+os_context_register_t *
+os_context_lr_addr(os_context_t *context)
+{
+#ifdef __NetBSD__
+    return &((context->uc_mcontext.__gregs)[_REG_LR]);
+#else
+#error unsupported BSD variant
+#endif
+}
+
+unsigned long
+os_context_fp_control(os_context_t *context)
+{
+#ifdef __NetBSD__
+    return &(context->uc_mcontext.__fpregs.__fpu_fpscr);
+#else
+#error unsupported BSD variant
+#endif
+}
+
+/* Copied verbatim from ppc-linux-os.c.  RMK 20051021 */
+void
+os_restore_fp_control(os_context_t *context)
+{
+    unsigned long control;
+    double d;
+
+    control = os_context_fp_control(context) &
+        /* FIXME: Should we preserve the user's requested rounding mode?
+
+        Note that doing
+
+        ~(FLOAT_STICKY_BITS_MASK | FLOAT_EXCEPTIONS_BYTE_MASK)
+
+        here leads to infinite SIGFPE for invalid operations, as
+        there are bits in the control register that need to be
+        cleared that are let through by that mask. -- CSR, 2002-07-16 */
+
+        FLOAT_TRAPS_BYTE_MASK;
+
+    d = *((double *) &control);
+    /* Hmp.  Apparently the following doesn't work either:
+
+    asm volatile ("mtfsf 0xff,%0" : : "f" (d));
+
+    causing segfaults at the first GC.
+    */
+}
+
+void
+os_flush_icache(os_vm_address_t address, os_vm_size_t length)
+{
+    /* see ppc-arch.c */
+    ppc_flush_icache(address,length);
+}
diff -purN -xCVS -x'*.d' -xcustomize-target-features.lisp sbcl/src/runtime/ppc-bsd-os.h sbcl-netbsd-ppc/src/runtime/ppc-bsd-os.h
--- sbcl/src/runtime/ppc-bsd-os.h	1969-12-31 19:00:00.000000000 -0500
+++ sbcl-netbsd-ppc/src/runtime/ppc-bsd-os.h	2005-10-21 21:09:49.000000000 -0400
@@ -0,0 +1,14 @@
+#ifndef _PPC_BSD_OS_H
+#define _PPC_BSD_OS_H
+
+/* typedef struct ucontext os_context_t; */
+/* typedef long os_context_register_t; */
+
+static inline os_context_t *arch_os_get_context(void **void_context) {
+    return (os_context_t *) *void_context;
+}
+
+unsigned long os_context_fp_control(os_context_t *context);
+void os_restore_fp_control(os_context_t *context);
+
+#endif /* _PPC_BSD_OS_H */
diff -purN -xCVS -x'*.d' -xcustomize-target-features.lisp sbcl/src/runtime/ppc-lispregs.h sbcl-netbsd-ppc/src/runtime/ppc-lispregs.h
--- sbcl/src/runtime/ppc-lispregs.h	2005-07-14 11:41:21.000000000 -0400
+++ sbcl-netbsd-ppc/src/runtime/ppc-lispregs.h	2005-12-11 00:20:30.000000000 -0500
@@ -22,7 +22,14 @@
 #define reg_NL6       REG(9)    /* Last (7th) FF param */
 #define reg_FDEFN     REG(10)   /* was NL7 until recently -dan */
 #define reg_NARGS     REG(11)
-#ifdef LISP_FEATURE_DARWIN
+/* Note: IIUC, NetBSD's trapframe constructor (in
+   sys/arch/powerpc/powerpc/trap.c) stores the frame pointer in the
+   13th register slot in the frame struct, which will get stored in
+   the 13th register slot in uc_mcontext, so that's where we need to
+   look for reg_NFP.  Perhaps that's what's going on in Darwin, too.
+   (This comment also applies to the contents of
+   src/compiler/ppc/vm.lisp.)  -- RMK, 20051029  */
+#if defined(LISP_FEATURE_DARWIN) || defined(LISP_FEATURE_NETBSD)
 #define reg_CFUNC     REG(12)   /* Silly to blow a reg on FF-name */
 #define reg_NFP       REG(13)   /* Lisp may save around FF-call */
 #else
Binary files sbcl/tools-for-build/grovel-headers- and sbcl-netbsd-ppc/tools-for-build/grovel-headers- differ
diff -purN -xCVS -x'*.d' -xcustomize-target-features.lisp sbcl/tools-for-build/ldso-stubs.lisp sbcl-netbsd-ppc/tools-for-build/ldso-stubs.lisp
--- sbcl/tools-for-build/ldso-stubs.lisp	2005-08-19 08:15:16.000000000 -0400
+++ sbcl-netbsd-ppc/tools-for-build/ldso-stubs.lisp	2005-12-10 19:40:07.000000000 -0500
@@ -85,7 +85,7 @@ ldso_stub__ ## fct: ;                   
 .L ## fct ## e1: ;                              \\
         .size    ldso_stub__ ## fct,.L ## fct ## e1-ldso_stub__ ## fct ;"
 
-#!+(and linux ppc) "
+#!+(and (or linux netbsd) ppc) "
 #define LDSO_STUBIFY(fct)                       \\
 .globl ldso_stub__ ## fct ;                     \\
         .type    ldso_stub__ ## fct,@function ; \\
@@ -278,7 +278,8 @@ ldso_stub__ ## fct: ;                  \
                  '("sigsetmask")))
 
 (with-open-file (f "src/runtime/ldso-stubs.S" :direction :output :if-exists :supersede)
-  (assert (= (length *preludes*) 2))
+  ;; I (RMK) can't remember why I disabled this assert on NetBSD.  Sorry.
+  #!-netbsd (assert (= (length *preludes*) 2))
   (dolist (pre *preludes*)
     (write-line pre f))
   (dolist (stub *stubs*)

[Sbcl-devel] Changes to GENCGC memory zeroing

[Juho Snellman <jsnell@ik...>]

Attached patch is intended to improve GENCGC performance, and seems to
mostly succeed in doing that. Unless there are objections, I'd like to
commit most of it for 0.9.8 (i.e. probably on next weekend). Testing
on non-Linux or low-memory x86 systems would be appreciated. Other
comments are of course also welcome.

  * Instead of zeroing memory by remapping memory with munmap/mmap at
    GC time, pages are just marked as needing zeroing and zeroed with
    memset when they're added to a new allocation region. This reduces
    GC latency both for the common and worst cases (~30% improvement
    for both on an Athlon X2 with kernel 2.6.14, ~5% average/~15%
    worst-case on a PIII/2.6.10).

    It also improves the performance of the whole Lisp system
    noticeably (up to 45% on some CL-BENCH tests on x86-64).  Attached
    are CL-BENCH results for a Pentium 120, Pentium III, Duron,
    Athlon, P IV, and Athlon X2. (Thanks to Hannu Koivisto and Peter
    De Wachter for some of these results). As a summary these results
    show mostly improvements on all platforms, with few significant
    regressions. (See the end of this message for some instructions on
    how to decipher the results).

  * To keep the memory footprint down, clear the pages by remapping after
    major GCs (arbitrarily defined as a collection of generation 2 or older).
    The memory freed from a minor GC is just going to get used again immediately,
    so releasing them back to the OS would make little sense.

    The RSS of a vanilla SBCL and a modified one acting are very
    similar for things like acting as a SBCL host compiler.
    Anecdotally the new version causes no more thrashing on a
    low-memory system than a vanilla one, though I haven't really
    measured this.

  * Supply hand-coded assembly routines for zeroing memory instead of
    relying on the libc memset() which seems to be suboptimal on a lot of
    systems.

      * On x86-64 use SSE2 (MOVNTDQ)
      * On x86 use either SSE2 (MOVNTDQ), MMX (MOVNTQ) or REP STOSL depending
        on CPUID flags.

    The extra complexity introduced here is quite manageable, since we're
    only using these routines for zeroing page-aligned blocks of memory.

    Separate results for this change are included in the CL-BENCH
    reports. As a summary, this is very beneficial for the SSE2
    systems and the PIII, quite good for the P120, and terrible for
    the Duron and the Athlon. Since the x86 results were mixed, this
    part is probably not something to commit in the 0.9.8 timeframe.

  * Shrink generation_size_t and reorganize struct page a bit to shrink
    the page-table (25% reduction on x86, 33% on x86-64). Reduces memory
    use and improves performance. This change is not included in any
    of the CL-BENCH reports.

  * Make MAP-ALLOCATED-OBJECTS page-table aware, so that the non-zero free
    pages don't confuse ROOM. As a bonus the results from ROOM are also
    more accurate now, instead of reporting each free page as consisting
    of a large number of conses.

  * On BSDs GENCGC always used memset instead of mmap tricks, apparently
    due to some bugs in swap space handling on some ancient FreeBSD version.
    Get rid of this irregularity, and do the same thing on all platforms.
    I'm not sure of the effect this will have on performance on BSDs.

  * Add a GENCGC mode (#define READ_PROTECT_FREE_PAGES) for catching attempts
    to read unallocated pages

  * Genesify the GENCGC page size


CL-BENCH readers guide:

Each file contains five columns:
  * Benchmark name
  * Absolute run-time for vanilla SBCL (on some boxes the tests were
    run with different iteration counts, so the absolute values of different
    reports are not comparable)
  * Relative run-time (to the vanilla results) for vanilla SBCL 
  * Relative run-time (to the vanilla results) for memset-using SBCL 
  * Relative run-time (to the vanilla results) for SBCL using 
    hand-optimized zeroing

Measurements are reported as xxx|yyy, where xxx is the result and yyy
is the standard error.

I'll make some pretty pictures of the results available later.

-- 
Juho Snellman