Skip to content
Snippets Groups Projects
Commit ba9940ba authored by cvs2git's avatar cvs2git
Browse files

This commit was manufactured by cvs2svn to create tag 'snapshot-2005-06'.

No related branches found
No related merge requests found
;;;;
;;;; Boot file for changing the fasl file version numbers to 19c.
;;;;
(in-package :c)
(setf lisp::*enable-package-locked-errors* nil)
;;;
;;; Note that BYTE-FASL-FILE-VERSION is a constant.
;;;
(setf (symbol-value 'byte-fasl-file-version) #x19c)
(setf (backend-fasl-file-version *target-backend*) #x19c)
;;;
;;; Don't check fasl versions in the compiling Lisp because we'll
;;; load files compiled with the new version numbers.
;;;
(setq lisp::*skip-fasl-file-version-check* t)
;;;
;;; This is here because BYTE-FASL-FILE-VERSION is constant-folded in
;;; OPEN-FASL-FILE. To make the new version number take effect, we
;;; have to redefine the function.
;;;
(defun open-fasl-file (name where &optional byte-p)
(declare (type pathname name))
(let* ((stream (open name :direction :output
:if-exists :new-version
:element-type '(unsigned-byte 8)))
(res (make-fasl-file :stream stream)))
(multiple-value-bind
(version f-vers f-imp)
(if byte-p
(values "Byte code"
byte-fasl-file-version
(backend-byte-fasl-file-implementation *backend*))
(values (backend-version *backend*)
(backend-fasl-file-version *backend*)
(backend-fasl-file-implementation *backend*)))
(format stream
"FASL FILE output from ~A.~@
Compiled ~A on ~A~@
Compiler ~A, Lisp ~A~@
Targeted for ~A, FASL version ~X~%"
where
(ext:format-universal-time nil (get-universal-time))
(machine-instance) compiler-version
(lisp-implementation-version)
version f-vers)
;;
;; Terminate header.
(dump-byte 255 res)
;;
;; Specify code format.
(dump-fop 'lisp::fop-long-code-format res)
(dump-byte f-imp res)
(dump-unsigned-32 f-vers res))
res))
;;;; end of boot-19c.lisp
(in-package :C)
(setf lisp::*enable-package-locked-errors* nil)
(handler-bind ((error (lambda (c)
(declare (ignore c))
(invoke-restart 'continue))))
(def-boolean-attribute ir1
;;
;; May call functions that are passed as arguments. In order to determine
;; what other effects are present, we must find the effects of all arguments
;; that may be functions.
call
;;
;; May incorporate function or number arguments into the result or somehow
;; pass them upward. Note that this applies to any argument that *might* be
;; a function or number, not just the arguments that always are.
unsafe
;;
;; May fail to return during correct execution. Errors are O.K.
unwind
;;
;; The (default) worst case. Includes all the other bad things, plus any
;; other possible bad thing. If this is present, the above bad attributes
;; will be explicitly present as well.
any
;;
;; May be constant-folded. The function has no side effects, but may be
;; affected by side effects on the arguments. e.g. SVREF, MAPC. Functions
;; that side-effect their arguments are not considered to be foldable.
;; Although it would be "legal" to constant fold them (since it "is an error"
;; to modify a constant), we choose not to mark theses functions as foldable
;; in this database.
foldable
;;
;; May be eliminated if value is unused. The function has no side effects
;; except possibly CONS. If a function is defined to signal errors, then it
;; is not flushable even if it is movable or foldable.
flushable
;;
;; May be moved with impunity. Has no side effects except possibly CONS, and
;; is affected only by its arguments.
movable
;;
;; Function is a true predicate likely to be open-coded. Convert any
;; non-conditional uses into (IF <pred> T NIL).
predicate
;;
;; Inhibit any warning for compiling a recursive definition. [Normally the
;; compiler warns when compiling a recursive definition for a known function,
;; since it might be a botched interpreter stub.]
recursive
;;
;; Function does explicit argument type checking, so the declared type should
;; not be asserted when a definition is compiled.
explicit-check
;;
;; Safe to stack-allocate function args that are closures.
dynamic-extent-closure-safe
;; Return value is important and ignoring it is probably a mistake.
;; This is for things like not using the result of nreverse. This
;; is only for warnings and has no effect on optimization.
important-result
))
(handler-bind ((error (lambda (c)
(declare (ignore c))
(invoke-restart 'kernel::clobber-it))))
(defstruct (function-info
(:print-function %print-function-info)
(:pure t))
;;
;; Boolean attributes of this function.
(attributes (required-argument) :type attributes)
;;
;; A list of Transform structures describing transforms for this function.
(transforms () :type list)
;;
;; A function which computes the derived type for a call to this function by
;; examining the arguments. This is null when there is no special method for
;; this function.
(derive-type nil :type (or function null))
;;
;; A function that does random unspecified code transformations by directly
;; hacking the IR. Returns true if further optimizations of the call
;; shouldn't be attempted.
(optimizer nil :type (or function null))
;;
;; If true, a special-case LTN annotation method that is used in place of the
;; standard type/policy template selection. It may use arbitrary code to
;; choose a template, decide to do a full call, or conspire with the
;; IR2-Convert method to do almost anything. The Combination node is passed
;; as the argument.
(ltn-annotate nil :type (or function null))
;;
;; If true, the special-case IR2 conversion method for this function. This
;; deals with funny functions, and anything else that can't be handled using
;; the template mechanism. The Combination node and the IR2-Block are passed
;; as arguments.
(ir2-convert nil :type (or function null))
;;
;; A list of all the templates that could be used to translate this function
;; into IR2, sorted by increasing cost.
(templates nil :type list)
;;
;; If non-null, then this function is a unary type predicate for this type.
(predicate-type nil :type (or ctype null))
;;
;; If non-null, use this function to annotate the known call for the byte
;; compiler. If it returns NIL, then change the call to :full.
(byte-annotate nil :type (or function null))
;;
;; If non-null, use this function to generate the byte code for this known
;; call. This function can only give up if there is a byte-annotate function
;; that arranged for the functional to be pushed onto the stack.
(byte-compile nil :type (or function null))
;; A function computing the constant or literal arguments which are
;; destructively modified by the call.
(destroyed-constant-args nil :type (or function null))
))
(in-package :C)
(setf lisp::*enable-package-locked-errors* nil)
(handler-bind ((error (lambda (c)
(declare (ignore c))
(invoke-restart 'continue))))
(def-boolean-attribute ir1
;;
;; May call functions that are passed as arguments. In order to determine
;; what other effects are present, we must find the effects of all arguments
;; that may be functions.
call
;;
;; May incorporate function or number arguments into the result or somehow
;; pass them upward. Note that this applies to any argument that *might* be
;; a function or number, not just the arguments that always are.
unsafe
;;
;; May fail to return during correct execution. Errors are O.K.
unwind
;;
;; The (default) worst case. Includes all the other bad things, plus any
;; other possible bad thing. If this is present, the above bad attributes
;; will be explicitly present as well.
any
;;
;; May be constant-folded. The function has no side effects, but may be
;; affected by side effects on the arguments. e.g. SVREF, MAPC. Functions
;; that side-effect their arguments are not considered to be foldable.
;; Although it would be "legal" to constant fold them (since it "is an error"
;; to modify a constant), we choose not to mark theses functions as foldable
;; in this database.
foldable
;;
;; May be eliminated if value is unused. The function has no side effects
;; except possibly CONS. If a function is defined to signal errors, then it
;; is not flushable even if it is movable or foldable.
flushable
;;
;; May be moved with impunity. Has no side effects except possibly CONS, and
;; is affected only by its arguments.
movable
;;
;; Function is a true predicate likely to be open-coded. Convert any
;; non-conditional uses into (IF <pred> T NIL).
predicate
;;
;; Inhibit any warning for compiling a recursive definition. [Normally the
;; compiler warns when compiling a recursive definition for a known function,
;; since it might be a botched interpreter stub.]
recursive
;;
;; Function does explicit argument type checking, so the declared type should
;; not be asserted when a definition is compiled.
explicit-check
;;
;; Safe to stack-allocate function args that are closures.
dynamic-extent-closure-safe
))
(handler-bind ((error (lambda (c)
(declare (ignore c))
(invoke-restart 'kernel::clobber-it))))
(defstruct (function-info
(:print-function %print-function-info)
(:pure t))
;;
;; Boolean attributes of this function.
(attributes (required-argument) :type attributes)
;;
;; A list of Transform structures describing transforms for this function.
(transforms () :type list)
;;
;; A function which computes the derived type for a call to this function by
;; examining the arguments. This is null when there is no special method for
;; this function.
(derive-type nil :type (or function null))
;;
;; A function that does random unspecified code transformations by directly
;; hacking the IR. Returns true if further optimizations of the call
;; shouldn't be attempted.
(optimizer nil :type (or function null))
;;
;; If true, a special-case LTN annotation method that is used in place of the
;; standard type/policy template selection. It may use arbitrary code to
;; choose a template, decide to do a full call, or conspire with the
;; IR2-Convert method to do almost anything. The Combination node is passed
;; as the argument.
(ltn-annotate nil :type (or function null))
;;
;; If true, the special-case IR2 conversion method for this function. This
;; deals with funny functions, and anything else that can't be handled using
;; the template mechanism. The Combination node and the IR2-Block are passed
;; as arguments.
(ir2-convert nil :type (or function null))
;;
;; A list of all the templates that could be used to translate this function
;; into IR2, sorted by increasing cost.
(templates nil :type list)
;;
;; If non-null, then this function is a unary type predicate for this type.
(predicate-type nil :type (or ctype null))
;;
;; If non-null, use this function to annotate the known call for the byte
;; compiler. If it returns NIL, then change the call to :full.
(byte-annotate nil :type (or function null))
;;
;; If non-null, use this function to generate the byte code for this known
;; call. This function can only give up if there is a byte-annotate function
;; that arranged for the functional to be pushed onto the stack.
(byte-compile nil :type (or function null))
;; A function computing the constant or literal arguments which are
;; destructively modified by the call.
(destroyed-constant-args nil :type (or function null))
;; If non-null, use this function to determine if the result of the
;; function is used or not. This is used to detect if you used a
;; destructive function but didn't use the result of the function.
(result-not-used nil :type (or function null))
))
(in-package "C")
(define-info-type typed-structure documentation (or string null))
;; This is a cross-compile script for ppc/darwin for moving the FDEFN
;; register. R10 is an integer arg register for calling C, so FDEFN
;; shouldn't be there.
(load "target:tools/cross-scripts/cross-ppc-ppc-darwin")
;; Needed by sparc to export the unix-sysinfo interface.
#+sparc
(load "target:code/exports.lisp")
========================== C M U C L 19 c =============================
The CMUCL project is pleased to announce the release of CMUCL 19c.
This is a major release which contains numerous enhancements and
bugfixes from the 19b release.
CMUCL is a free, high performance implementation of the Common Lisp
programming language which runs on most major Unix platforms. It
mainly conforms to the ANSI Common Lisp standard. CMUCL provides a
sophisticated native code compiler; a powerful foreign function
interface; an implementation of CLOS, the Common Lisp Object System,
which includes multimethods and a metaobject protocol; a source-level
debugger and code profiler; and an Emacs-like editor implemented in
Common Lisp. CMUCL is maintained by a team of volunteers collaborating
over the Internet, and is mostly in the public domain.
New in this release:
* Feature enhancements:
- Cross-reference information can now be saved to a fasl file.
- COMPILE-FILE accepts the new keyword arg :XREF. When non-NIL,
cross-reference information found during compilation is saved
to the fasl file.
- UNIX-UNAME added for non-glibc2 platforms, which already had
it.
- Added annotation support to the pretty printer so various
annotations can be produced in sync with the pretty printer
output. (From Matthias Koeppe.) Arbitrary functions
("annotations") can be queued in sequence with characters that
are printed to the pretty stream. When the characters are
forwarded to the target stream, the annotations are invoked at
the right position.
- Add a restart for ENSURE-DIRECTORIES-EXIST to retry directory
creation if necessary.
* Numerous ANSI compliance fixes:
- FILE-POSITION on string input streams accept :START and :END
for the position.
- The default value for keyword args for deftype is '*, not NIL.
- ED is now defined (but does nothing). Loading hemlock will
give you an ED that works.
- DOCUMENTATION and (SETF DOCUMENTATION) works for more cases
now.
- MULTIPLE-VALUE-SETQ now always returns the primary value.
- (SETF MACRO-FUNCTION) and (SETF COMPILER-MACRO-FUNCTION)
accepts the optional environment arg, as specified by ANSI CL.
- PRIN1 no longer prints the sign of the exponent if it is
non-negative.
- PRIN1 and ~E are consistent now when printing large numbers.
- Undefined-Function errors from funcalling special forms now
have the cell-error name filled in correctly.
- ENOUGH-NAMESTRING was not returning the shortest namestring
when the defaults was #p"/".
- TRANSLATE-PATHNAME signals an error if (PATHNAME-MATCH-P
source from-wildcard) is not true.
- ENOUGH-NAMESTRING was returning a pathname object instead of a
string for logical pathnames.
- ENOUGH-NAMESTRING no longer returns relative pathnames if the
pathname and the defaults have nothing in common.
- PARSE-NAMESTRING will accept a string for the DEFAULTS
parameter, as specified by ANSI.
* Numerous bugfixes:
- Regression in MRG32K3A benchmark fixed.
- (format t "~8,2f" -0.0) has the right length now. This
happened because we didn't recognize -0.0 is negative.
- Type derivation for FTRUNCATE is now consistent with what
FTRUNCATE returns. Main problem was that -0.0 is now returned
by ftruncate instead of +0.0.
- Some errors during type derivation are fixed. We cause the
offending function to return NIL to indicate unbounded.
- Errors in callbacks for the ppc and sparc ports when the
integer arg is shorter than an int have been fixed.
- ASIN and ACOS returns NaN when given NaN args instead of
signaling an error.
- FTRUNCATE will return a quiet NaN when given a signaling NaN.
It also properly handles infinity too.
- Fixed a bug in handling of alien enum types in structures.
- (MAKE-PATHNAME :DIRECTORY '(:RELATIVE)) now prints as #P"./"
instead of #p"", which is the printed form of (MAKE-PATHNAME).
- Relative directories for MAKE-PATHNAME now have all "."
elements removed. This makes it consistent with the reader.
- A warning is printed if an element of the directory component
of a pathname consists of a string containing the "/"
character.
- Namestrings for pathnames with a NIL host will now be
generated using the host from *DEFAULT-PATHNAME-DEFAULTS*, or
*UNIX-HOST* instead of producing an error.
- ENOUGH-NAMESTRING returns the pathname if the host for the
pathname differs from the host for the defaults.
- CMUCL recognizes multi-arch (fat) shared libs on Darwin/ppc.
It's now possible to load libSystem.dylib.
- #p".." is read as a directory instead of as a file with name
#"." and type "".
- #p"..." and similar forms with more dots is read as a file
with name equal to the string and type nil. Previously, the
name had one fewer dot with type "".
- MAKE-PATHNAME with :name equal to ".." or "." will generate a
warning because CMUCL cannot print that in a form that will be
read back the same.
- ENOUGH-NAMESTRING will work with search-lists, but only looks
at the first path in the search-list. This is mostly to
handle the home: search-list, which only has one path by
default.
- SXHASH will hash the components of a pathname object together
instead of returning the same hash value for all pathname
objects.
- EQUAL for pathnames treats version NIL and version :NEWEST to
be equal.
- PPC callbacks were not preserving register values and
therefore produced erroneous values.
- PROBE-FILE for a pathname that is actually a directory returns
a pathname indicating that it is a directory.
- LISTEN on DUAL-CHANNEL-SIMPLE-STREAM should work now.
* Other changes:
- Due to some bugs in modular arithmetic, generating either
wrong code or much slower code, you can now disable modular
arithmetic by setting c::*enable-modular-arithmetic* to NIL.
This is a workaround pending a better solution.
- Support logical pathnames when using LOAD-OBJECT-FILE.
- Namestrings that are being parsed will not produce a
search-list if a logical host with the same name already
exists. An error is signaled in this case.
- Tracing with :encapsulate nil does not work very well on ppc.
The default for tracing on ppc is to encapsulate. (Tracing
functions with the known-return convention using :encapsulate
nil works, however.)
* Improvements to the PCL implementation of CLOS:
* Changes to rebuilding procedure:
- Build scripts should recognize FreeBSD automatically.
- Should be able to build on either Mac OS X 10.2 or 10.4 using
the default version of gcc.
This release is not binary compatible with code compiled using CMUCL
19b; you will need to recompile FASL files.
See <URL:http://www.cons.org/cmucl/> for download information,
guidelines on reporting bugs, and mailing list details.
We hope you enjoy using this release of CMUCL!
========================== C M U C L 19 d =============================
[--- WORK IN PROGRESS --- DO NOT DISTRIBUTE ---]
The CMUCL project is pleased to announce the release of CMUCL 19d.
This is a major release which contains numerous enhancements and
bugfixes from the 19c release.
CMUCL is a free, high performance implementation of the Common Lisp
programming language which runs on most major Unix platforms. It
mainly conforms to the ANSI Common Lisp standard. CMUCL provides a
sophisticated native code compiler; a powerful foreign function
interface; an implementation of CLOS, the Common Lisp Object System,
which includes multimethods and a metaobject protocol; a source-level
debugger and code profiler; and an Emacs-like editor implemented in
Common Lisp. CMUCL is maintained by a team of volunteers collaborating
over the Internet, and is mostly in the public domain.
New in this release:
* Feature enhancements:
- Destructive functions like nreverse that modify constant args
will produce a warning.
- Destructive functions like nreverse whose results are not used
will produce a warning.
- Pathnames that cannot be printed readably using #p"..." will
now be printed using the CMUCL extension #P(...). However,
there are still cases where CMUCL cannot print pathnames
readably, but these involve search-lists and patterns.
- LONG-LONG and UNSIGNED-LONG-LONG are recognized types in the
C-CALL package for signed and unsigned 64-bit integers.
- A port of gencgc to Darwin/ppc has been made. This still
needs work, and is known to have some issues.
* Numerous ANSI compliance fixes:
- A reader-error is signaled if the number that is being read is
too small to be presented. We used to silently return 0.
- WITH-INPUT-FROM-STRING no longer modifies the index if
WITH-INPUT-FROM-STRING is not exited normally.
- An error is signaled if a declaration is used as the name of a
deftype, condition, or defstruct, and vice versa.
- An error is signaled when trying to generate a namestring from
a pathname with just a version component (other than nil,
:newest, or :unspecific). CMUCL cannot print that readably.
- FLET and LABELS functions will catch errors in keyword
parameters. Previously, a keyword of NIL was silently
accepted.
- Printing a zero using ~E will now include a trailing zero
after the decimal point, as required by CLHS, 22.3.3.2.
- DOCUMENTATION and (SETF DOCUMENTATION) now works for
structures of type list or vector.
- DOTIMES will execute the loop the specified number of times,
independent of what the loop might do to the loop counter.
* Numerous bugfixes:
- LISTEN on DUAL-CHANNEL-SIMPLE-STREAM should work now.
- Some numerical issues with the two-arg log function have been
fixed. (log 17 10f0), (log 17f0 10) and (log 17 10) all
return the same result now.
- DESTRUCTURING-BIND no longer causes an error when the list to
be destructured is circular.
- PEEK-CHAR for Gray streams handles end of file correctly now.
- For the ppc port, the alignment of objects in alien structures
now matches the PowerOpen ABI for Mac OS X.
- For Darwin/ppc, CMUCL was not following the ABI when calling
out to C varargs functions. Now we always copy any float args
to the corresponding int regs (or stack) as required by the
ABI. This isn't necessary for non-varargs functions, but
CMUCL doesn't know functions which are varargs functions.
- Callbacks with long-long args or results should work correctly
now for Darwin/ppc.
- DESCRIBE no longer depends on having PCL loaded.
- Tracing with no encapsulation appears to be working now for
ppc.
- A simple interface to sysinfo(2) has been added for sparc.
This is used to provide better values for MACHINE-TYPE and
MACHINE-VERSION.
* Other changes:
- CMUCL catches more cases where it cannot print a pathname
readably. In particular when the pathname name contains "/"
or ".", or when the pathname type contains a ".".
* Improvements to the PCL implementation of CLOS:
* Changes to rebuilding procedure:
- Build scripts should recognize FreeBSD automatically.
- Should be able to build on either Mac OS X 10.2 or 10.4 using
the default version of gcc.
This release is not binary compatible with code compiled using CMUCL
19c; you will need to recompile FASL files.
See <URL:http://www.cons.org/cmucl/> for download information,
guidelines on reporting bugs, and mailing list details.
We hope you enjoy using this release of CMUCL!
/* For GNU indent */
--indent-level4
--line-length80
--braces-on-if-line
--cuddle-else
--braces-on-struct-decl-line
--dont-format-first-column-comments
--continue-at-parentheses
--no-space-after-function-call-names
--leave-optional-blank-lines
--break-before-boolean-operator
--blank-lines-after-declarations
--blank-lines-after-procedures
--case-indentation2
(in-package :cl-user)
;;; Rename the X86 package and backend so that new-backend does the
;;; right thing.
(rename-package "X86" "OLD-X86")
(setf (c:backend-name c:*native-backend*) "OLD-X86")
(c::new-backend "X86"
;; Features to add here
'(:x86 :i486 :pentium
:stack-checking :heap-overflow-check :mp :gencgc :netbsd
:conservative-float-type :linkage-table
:hash-new :random-mt19937 :modular-arith :small
:cmu :cmu18 :cmu18e :cmu19 :cmu19a
:no-pcl :no-clx :no-clm :no-hemlock
)
;; Features to remove from current *features* here
'(:x86-bootstrap :alpha :osf1 :mips :ppc :sparc
:propagate-fun-type :propagate-float-type :constrain-float-type
:openbsd :freebsd :freebsd4 :glibc2 :glibc2.1 :linux
:long-float :new-random))
;(load "target:bootfiles/19c/boot-2005-11-1.lisp")
;(load "target:bootfiles/19c/boot-2005-11-2.lisp")
;;; Extern-alien-name for the new backend.
(in-package :vm)
(defun extern-alien-name (name)
(declare (type simple-string name))
name)
(export 'extern-alien-name)
(export 'fixup-code-object)
(export 'sanctify-for-execution)
;;; Compile the new backend.
(pushnew :bootstrap *features*)
(pushnew :building-cross-compiler *features*)
(load "target:tools/comcom")
;;; Load the new backend.
(setf (search-list "c:")
'("target:compiler/"))
(setf (search-list "vm:")
'("c:x86/" "c:generic/"))
(setf (search-list "assem:")
'("target:assembly/" "target:assembly/x86/"))
;; Load the backend of the compiler.
(in-package "C")
(load "vm:vm-macs")
(load "vm:parms")
(load "vm:objdef")
(load "vm:interr")
(load "assem:support")
(load "target:compiler/srctran")
(load "vm:vm-typetran")
(load "target:compiler/float-tran")
(load "target:compiler/saptran")
(load "vm:macros")
(load "vm:utils")
(load "vm:vm")
(load "vm:insts")
(load "vm:primtype")
(load "vm:move")
(load "vm:sap")
(load "vm:system")
(load "vm:char")
(load "vm:float")
(load "vm:memory")
(load "vm:static-fn")
(load "vm:arith")
(load "vm:cell")
(load "vm:subprim")
(load "vm:debug")
(load "vm:c-call")
(load "vm:print")
(load "vm:alloc")
(load "vm:call")
(load "vm:nlx")
(load "vm:values")
(load "vm:array")
(load "vm:pred")
(load "vm:type-vops")
(load "assem:assem-rtns")
(load "assem:array")
(load "assem:arith")
(load "assem:alloc")
(load "c:pseudo-vops")
(check-move-function-consistency)
(load "vm:new-genesis")
;;; OK, the cross compiler backend is loaded.
(setf *features* (remove :building-cross-compiler *features*))
;;; Info environment hacks.
(macrolet ((frob (&rest syms)
`(progn ,@(mapcar #'(lambda (sym)
`(defconstant ,sym
(symbol-value
(find-symbol ,(symbol-name sym)
:vm))))
syms))))
(frob OLD-X86:BYTE-BITS OLD-X86:WORD-BITS
#+long-float OLD-X86:SIMPLE-ARRAY-LONG-FLOAT-TYPE
OLD-X86:SIMPLE-ARRAY-DOUBLE-FLOAT-TYPE
OLD-X86:SIMPLE-ARRAY-SINGLE-FLOAT-TYPE
#+long-float OLD-X86:SIMPLE-ARRAY-COMPLEX-LONG-FLOAT-TYPE
OLD-X86:SIMPLE-ARRAY-COMPLEX-DOUBLE-FLOAT-TYPE
OLD-X86:SIMPLE-ARRAY-COMPLEX-SINGLE-FLOAT-TYPE
OLD-X86:SIMPLE-ARRAY-UNSIGNED-BYTE-2-TYPE
OLD-X86:SIMPLE-ARRAY-UNSIGNED-BYTE-4-TYPE
OLD-X86:SIMPLE-ARRAY-UNSIGNED-BYTE-8-TYPE
OLD-X86:SIMPLE-ARRAY-UNSIGNED-BYTE-16-TYPE
OLD-X86:SIMPLE-ARRAY-UNSIGNED-BYTE-32-TYPE
OLD-X86:SIMPLE-ARRAY-SIGNED-BYTE-8-TYPE
OLD-X86:SIMPLE-ARRAY-SIGNED-BYTE-16-TYPE
OLD-X86:SIMPLE-ARRAY-SIGNED-BYTE-30-TYPE
OLD-X86:SIMPLE-ARRAY-SIGNED-BYTE-32-TYPE
OLD-X86:SIMPLE-BIT-VECTOR-TYPE
OLD-X86:SIMPLE-STRING-TYPE OLD-X86:SIMPLE-VECTOR-TYPE
OLD-X86:SIMPLE-ARRAY-TYPE OLD-X86:VECTOR-DATA-OFFSET
))
(let ((function (symbol-function 'kernel:error-number-or-lose)))
(let ((*info-environment* (c:backend-info-environment c:*target-backend*)))
(setf (symbol-function 'kernel:error-number-or-lose) function)
(setf (info function kind 'kernel:error-number-or-lose) :function)
(setf (info function where-from 'kernel:error-number-or-lose) :defined)))
(defun fix-class (name)
(let* ((new-value (find-class name))
(new-layout (kernel::%class-layout new-value))
(new-cell (kernel::find-class-cell name))
(*info-environment* (c:backend-info-environment c:*target-backend*)))
(remhash name kernel::*forward-referenced-layouts*)
(kernel::%note-type-defined name)
(setf (info type kind name) :instance)
(setf (info type class name) new-cell)
(setf (info type compiler-layout name) new-layout)
new-value))
(fix-class 'c::vop-parse)
(fix-class 'c::operand-parse)
#+random-mt19937
(declaim (notinline kernel:random-chunk))
(setf c:*backend* c:*target-backend*)
;;; Extern-alien-name for the new backend.
(in-package :vm)
(defun extern-alien-name (name)
(declare (type simple-string name))
name)
(export 'extern-alien-name)
(export 'fixup-code-object)
(export 'sanctify-for-execution)
(in-package :cl-user)
;;; Don't load compiler parts from the target compilation
(defparameter *load-stuff* nil)
;; hack, hack, hack: Make old-x86::any-reg the same as
;; x86::any-reg as an SC. Do this by adding old-x86::any-reg
;; to the hash table with the same value as x86::any-reg.
(let ((ht (c::backend-sc-names c::*target-backend*)))
(setf (gethash 'old-x86::any-reg ht)
(gethash 'x86::any-reg ht)))
;; e.g. for FreeBSD on x86 you probably want:
;;(pushnew :freebsd4 *features*)
;;(pushnew :freebsd *features*)
;;(pushnew :elf *features*)
;; We can't really do this before adding #+freebsd5 reader
;; conditionals to the source code at appropiate places
;; (setf *features* (remove :freebsd4 *features*))
;; (pushnew :freebsd5 *features*)
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment