src/compiler/generic/target-core.lisp

   1 ;;;; target-only code that knows how to load compiled code directly
   2 ;;;; into core
   3
   4 ;;;; This software is part of the SBCL system. See the README file for
   5 ;;;; more information.
   6 ;;;;
   7 ;;;; This software is derived from the CMU CL system, which was
   8 ;;;; written at Carnegie Mellon University and released into the
   9 ;;;; public domain. The software is in the public domain and is
  10 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
  11 ;;;; files for more information.
  12
  13 (in-package "SB!C")
  14
  15 ;;; Make a function entry, filling in slots from the ENTRY-INFO.
  16 (defun make-function-entry (entry code-obj object)
  17   (declare (type entry-info entry) (type core-object object))
  18   (let ((offset (label-position (entry-info-offset entry))))
  19     (declare (type index offset))
  20     (unless (zerop (logand offset sb!vm:lowtag-mask))
  21       (error "Unaligned function object, offset = #X~X." offset))
  22     (let ((res (%primitive compute-function code-obj offset)))
  23       (setf (%function-self res) res)
  24       (setf (%function-next res) (%code-entry-points code-obj))
  25       (setf (%code-entry-points code-obj) res)
  26       (setf (%function-name res) (entry-info-name entry))
  27       (setf (%function-arglist res) (entry-info-arguments entry))
  28       (setf (%function-type res) (entry-info-type entry))
  29
  30       (note-function entry res object))))
  31
  32 ;;; Dump a component to core. We pass in the assembler fixups, code vector
  33 ;;; and node info.
  34 (defun make-core-component (component segment length trace-table fixups object)
  35   (declare (type component component)
  36            (type sb!assem:segment segment)
  37            (type index length)
  38            (list trace-table fixups)
  39            (type core-object object))
  40   (without-gcing
  41     (let* ((2comp (component-info component))
  42            (constants (ir2-component-constants 2comp))
  43            (trace-table (pack-trace-table trace-table))
  44            (trace-table-len (length trace-table))
  45            (trace-table-bits (* trace-table-len tt-bits-per-entry))
  46            (total-length (+ length (ceiling trace-table-bits sb!vm:byte-bits)))
  47            (box-num (- (length constants) sb!vm:code-trace-table-offset-slot))
  48            #!+x86
  49            (code-obj
  50             ;; FIXME: What is this *ENABLE-DYNAMIC-SPACE-CODE* stuff?
  51             (if (and (boundp sb!impl::*enable-dynamic-space-code*)
  52                      sb!impl::*enable-dynamic-space-code*)
  53                 (%primitive allocate-dynamic-code-object box-num total-length)
  54               (%primitive allocate-code-object box-num total-length)))
  55            #!-x86
  56            (code-obj
  57             (%primitive allocate-code-object box-num total-length))
  58            (fill-ptr (code-instructions code-obj)))
  59       (declare (type index box-num total-length))
  60
  61       (sb!assem:on-segment-contents-vectorly
  62        segment
  63        (lambda (v)
  64          (declare (type (simple-array sb!assem:assembly-unit 1) v))
  65          (copy-byte-vector-to-system-area v fill-ptr)
  66          (setf fill-ptr (sap+ fill-ptr (length v)))))
  67
  68       (do-core-fixups code-obj fixups)
  69
  70       (dolist (entry (ir2-component-entries 2comp))
  71         (make-function-entry entry code-obj object))
  72
  73       (sb!vm:sanctify-for-execution code-obj)
  74
  75       (let ((info (debug-info-for-component component)))
  76         (push info (core-object-debug-info object))
  77         (setf (%code-debug-info code-obj) info))
  78
  79       (setf (code-header-ref code-obj sb!vm:code-trace-table-offset-slot) length)
  80       (copy-to-system-area trace-table
  81                            (* sb!vm:vector-data-offset sb!vm:word-bits)
  82                            fill-ptr
  83                            0
  84                            trace-table-bits)
  85
  86       (do ((index sb!vm:code-constants-offset (1+ index)))
  87           ((>= index (length constants)))
  88         (let ((const (aref constants index)))
  89           (etypecase const
  90             (null)
  91             (constant
  92              (setf (code-header-ref code-obj index)
  93                    (constant-value const)))
  94             (list
  95              (ecase (car const)
  96                (:entry
  97                 (reference-core-function code-obj index
  98                                          (cdr const) object))
  99                (:fdefinition
 100                 (setf (code-header-ref code-obj index)
 101                       (sb!impl::fdefinition-object (cdr const) t))))))))))
 102   (values))
 103
 104 (defun make-core-byte-component (segment length constants xeps object)
 105   (declare (type sb!assem:segment segment)
 106            (type index length)
 107            (type vector constants)
 108            (type list xeps)
 109            (type core-object object))
 110   (without-gcing
 111     (let* ((num-constants (length constants))
 112            ;; KLUDGE: On the X86, using ALLOCATE-CODE-OBJECT is
 113            ;; supposed to make the result non-relocatable, which is
 114            ;; probably not what we want. Could this be made into
 115            ;; ALLOCATE-DYNAMIC-CODE-OBJECT? Is there some other fix?
 116            ;; Am I just confused? -- WHN 19990916
 117            (code-obj (%primitive allocate-code-object
 118                                  (the index (1+ num-constants))
 119                                  length))
 120            (fill-ptr (code-instructions code-obj)))
 121       (declare (type index length)
 122                (type system-area-pointer fill-ptr))
 123       (sb!assem:on-segment-contents-vectorly
 124        segment
 125        (lambda (v)
 126          (declare (type (simple-array sb!assem:assembly-unit 1) v))
 127          (copy-byte-vector-to-system-area v fill-ptr)
 128          (setf fill-ptr (sap+ fill-ptr (length v)))))
 129
 130       (setf (code-header-ref code-obj sb!vm:code-trace-table-offset-slot)
 131             nil)
 132       (dolist (noise xeps)
 133         (let ((xep (cdr noise)))
 134           (setf (byte-function-component xep) code-obj)
 135           (initialize-byte-compiled-function xep)
 136           (note-function (lambda-info (car noise)) xep object)))
 137
 138       (dotimes (index num-constants)
 139         (let ((const (aref constants index))
 140               (code-obj-index (+ index sb!vm:code-constants-offset)))
 141           (etypecase const
 142             (null)
 143             (constant
 144              (setf (code-header-ref code-obj code-obj-index)
 145                    (constant-value const)))
 146             (list
 147              (ecase (car const)
 148                (:entry
 149                 (reference-core-function code-obj code-obj-index (cdr const)
 150                                          object))
 151                (:fdefinition
 152                 (setf (code-header-ref code-obj code-obj-index)
 153                       (sb!impl::fdefinition-object (cdr const) t)))
 154                (:type-predicate
 155                 (let ((*unparse-function-type-simplify* t))
 156                   (setf (code-header-ref code-obj code-obj-index)
 157                         (load-type-predicate (type-specifier (cdr const))))))
 158                (:xep
 159                 (let ((xep (cdr (assoc (cdr const) xeps :test #'eq))))
 160                   (aver xep)
 161                   (setf (code-header-ref code-obj code-obj-index) xep))))))))))
 162
 163   (values))
 164