mirror of
https://git.savannah.gnu.org/git/guile.git
synced 2025-06-12 06:41:13 +02:00
53e28ed9b2
* gdbinit: Untested attempts to get the stack fondling macros to deal with the new program representation. * libguile/frames.c (scm_vm_frame_arguments, scm_vm_frame_source) (scm_vm_frame_local_ref, scm_vm_frame_local_set_x): SCM_PROGRAM_DATA is a struct scm_objcode*. * libguile/instructions.h: * libguile/instructions.c: Hide the instruction table and the struct scm_instruction structure; all access to instructions now goes through procedures. This is because instructions are no longer in a packed array indexed by opcode. Also, declare a mask that all instructions should fit in. * libguile/objcodes.h: * libguile/objcodes.c: Rewrite so that object code directly maps its arity and length from its bytecode. This makes it unnecessary to keep this information in programs, allowing programs to be simple conses between the code (objcodes) and data (the object table and the closure variables). * libguile/programs.c (scm_make_program): Rework so that make-program takes objcode, an object table, and externals as arguments. It's much clearer this way, and we avoid malloc(). * libguile/stacks.c (is_vm_bootstrap_frame): Update for program/objcode changes. * libguile/vm-engine.c (vm_run): Initialize the jump table on the first run, with the opcodes declared in the instruction sources, and with bad instructions raising an error instead of wandering off into the Unknown. * libguile/vm-engine.h (FETCH_LENGTH): Always represent lengths as 3 bytes. The old code was too error-prone. (NEXT_JUMP): Mask the instruction with SCM_VM_INSTRUCTION_MASK. (NEW_FRAME): Update for program/objcode changes. * libguile/vm-expand.h (VM_DEFINE_FUNCTION, VM_DEFINE_INSTRUCTION) (VM_DEFINE_LOADER): Update so that we explicitly specify opcodes, so that we have a stable bytecode API. * libguile/vm-i-loader.c: Update license to LGPLv2+. Explicitly declare opcodes. (load-integer): Use an int instead of a long as the accumulator; still need to revisit this code at some point, I think. (load-program): Simplify, thankfully!! Just creates the objcode slice and rolls with it. * libguile/vm-i-scheme.c: Number the opcodes explicitly. * libguile/vm-i-system.c: Update license to LGPLv2+. Explicitly declare opcodes. (make-closure): Update for new program API. * libguile/vm.c (vm_make_boot_program): Update for new program/objcode API. Still a bit ugly. (scm_load_compiled_with_vm): Update for new program/objcode API. * module/language/assembly.scm (byte-length): Fix byte-length calculation for loaders, and load-program. (code-pack, code-unpack): Start to move things from (system vm conv) here. (object->code, code->object): More things from conv.scm. * module/language/glil.scm (<glil-program>): Add a new field, closure-level. (make-glil-program, compute-closure-level): Calculate the "closure level" when making a glil program. This is the maximum depth of external binding refs in this closure. (unparse-glil): Fix label serialization. * module/language/glil/compile-assembly.scm (make-meta): Prepend #f for the meta's object table, though maybe in the future we can avoid creating assembly in the first place. (assoc-ref-or-acons, object-index-and-alist): GRRR! Caught again by the different sets of arguments to assoc and assoc-ref! (glil->assembly): Attempt to make the <glil-program> case more readable, and fix the bugs. Sorry I don't know how to comment this change any more than this. (glil->assembly): For <glil-module> serialize the whole key, not just the name. (dump-object): subprogram-code is already a list. Serialize integers as strings, not u8vectors. Fix the order of lists and vectors. * module/language/glil/spec.scm (glil): Switch orders, so we prefer glil -> assembly -> objcode. Actually glil->objcode doesn't work any more, needs to be removed I think. * module/language/objcode/spec.scm (objcode->value): s/objcode->program/make-program/. * module/language/scheme/inline.scm: Add acons inline. * module/system/vm/conv.scm (make-byte-decoder): Skip the first 8 bytes, they are header. Handle subprograms properly. Still needs help though. (decode-length): Lengths are always 3 bytes now. * module/system/vm/disasm.scm: Superficial changes to keep things working. I'd like to fix this better in the future. * module/system/vm/frame.scm (bootstrap-frame?): Fixes for program-bytecode. * module/system/vm/program.scm: Export make-program. It's program-objcode now, no more program-bytecode. * module/system/vm/vm.scm (vm-load): Use make-program. * test-suite/tests/asm-to-bytecode.test: New test, very minimal. * module/system/vm/objcode.scm: Export word-size, byte-order, and write-objcode.
216 lines
7.2 KiB
Scheme
216 lines
7.2 KiB
Scheme
;;; Guile VM frame functions
|
||
|
||
;;; Copyright (C) 2001 Free Software Foundation, Inc.
|
||
;;; Copyright (C) 2005 Ludovic Courtès <ludovic.courtes@laas.fr>
|
||
;;;
|
||
;;; This program is free software; you can redistribute it and/or modify
|
||
;;; it under the terms of the GNU General Public License as published by
|
||
;;; the Free Software Foundation; either version 2 of the License, or
|
||
;;; (at your option) any later version.
|
||
;;;
|
||
;;; This program is distributed in the hope that it will be useful,
|
||
;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
;;; GNU General Public License for more details.
|
||
;;;
|
||
;;; You should have received a copy of the GNU General Public License
|
||
;;; along with this program; if not, write to the Free Software
|
||
;;; Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||
|
||
;;; Code:
|
||
|
||
(define-module (system vm frame)
|
||
#:use-module (system vm program)
|
||
#:use-module (system vm instruction)
|
||
#:use-module ((srfi srfi-1) #:select (fold))
|
||
#:export (vm-frame?
|
||
vm-frame-program
|
||
vm-frame-local-ref vm-frame-local-set!
|
||
vm-frame-return-address vm-frame-mv-return-address
|
||
vm-frame-dynamic-link vm-frame-external-link
|
||
vm-frame-stack
|
||
|
||
|
||
vm-frame-number vm-frame-address
|
||
make-frame-chain
|
||
print-frame print-frame-chain-as-backtrace
|
||
frame-arguments frame-local-variables frame-external-variables
|
||
frame-environment
|
||
frame-variable-exists? frame-variable-ref frame-variable-set!
|
||
frame-object-name
|
||
frame-local-ref frame-external-link frame-local-set!
|
||
frame-return-address frame-program
|
||
frame-dynamic-link heap-frame?))
|
||
|
||
;; fixme: avoid the dynamic-call?
|
||
(dynamic-call "scm_init_frames" (dynamic-link "libguile"))
|
||
|
||
;;;
|
||
;;; Frame chain
|
||
;;;
|
||
|
||
(define vm-frame-number (make-object-property))
|
||
(define vm-frame-address (make-object-property))
|
||
|
||
;; FIXME: the header.
|
||
(define (bootstrap-frame? frame)
|
||
(let ((code (objcode->u8vector (program-objcode (frame-program frame)))))
|
||
(and (= (uniform-vector-length code) 6)
|
||
(= (uniform-vector-ref code 5)
|
||
(instruction->opcode 'halt)))))
|
||
|
||
(define (make-frame-chain frame addr)
|
||
(define (make-rest)
|
||
(make-frame-chain (frame-dynamic-link frame)
|
||
(frame-return-address frame)))
|
||
(cond
|
||
((or (eq? frame #t) (eq? frame #f))
|
||
;; handle #f or #t dynamic links
|
||
'())
|
||
((bootstrap-frame? frame)
|
||
(make-rest))
|
||
(else
|
||
(let ((chain (make-rest)))
|
||
(set! (frame-number frame) (length chain))
|
||
(set! (frame-address frame)
|
||
(- addr (program-base (frame-program frame))))
|
||
(cons frame chain)))))
|
||
|
||
|
||
;;;
|
||
;;; Pretty printing
|
||
;;;
|
||
|
||
(define (frame-line-number frame)
|
||
(let ((addr (frame-address frame)))
|
||
(cond ((assv addr (program-sources (frame-program frame)))
|
||
=> source:line)
|
||
(else (format #f "@~a" addr)))))
|
||
|
||
(define (frame-file frame prev)
|
||
(let ((sources (program-sources (frame-program frame))))
|
||
(if (null? sources)
|
||
prev
|
||
(or (source:file (car sources))
|
||
"current input"))))
|
||
|
||
(define (print-frame frame)
|
||
(format #t "~4@a: ~a ~s\n" (frame-line-number frame) (frame-number frame)
|
||
(frame-call-representation frame)))
|
||
|
||
|
||
(define (frame-call-representation frame)
|
||
(define (abbrev x)
|
||
(cond ((list? x)
|
||
(if (> (length x) 4)
|
||
(list (abbrev (car x)) (abbrev (cadr x)) '...)
|
||
(map abbrev x)))
|
||
((pair? x)
|
||
(cons (abbrev (car x)) (abbrev (cdr x))))
|
||
((vector? x)
|
||
(case (vector-length x)
|
||
((0) x)
|
||
((1) (vector (abbrev (vector-ref x 0))))
|
||
(else (vector (abbrev (vector-ref x 0)) '...))))
|
||
(else x)))
|
||
(abbrev (cons (frame-program-name frame) (frame-arguments frame))))
|
||
|
||
(define (print-frame-chain-as-backtrace frames)
|
||
(if (null? frames)
|
||
(format #t "No backtrace available.\n")
|
||
(begin
|
||
(format #t "VM backtrace:\n")
|
||
(fold (lambda (frame file)
|
||
(let ((new-file (frame-file frame file)))
|
||
(if (not (equal? new-file file))
|
||
(format #t "In ~a:\n" new-file))
|
||
(print-frame frame)
|
||
new-file))
|
||
'no-file
|
||
frames))))
|
||
|
||
(define (frame-program-name frame)
|
||
(let ((prog (frame-program frame))
|
||
(link (frame-dynamic-link frame)))
|
||
(or (program-name prog)
|
||
(object-property prog 'name)
|
||
(and (heap-frame? link) (frame-address link)
|
||
(frame-object-name link (1- (frame-address link)) prog))
|
||
(hash-fold (lambda (s v d) (if (and (variable-bound? v)
|
||
(eq? prog (variable-ref v)))
|
||
s d))
|
||
prog (module-obarray (current-module))))))
|
||
|
||
|
||
;;;
|
||
;;; Frames
|
||
;;;
|
||
|
||
(define (frame-arguments frame)
|
||
(let* ((prog (frame-program frame))
|
||
(arity (program-arity prog)))
|
||
(do ((n (+ (arity:nargs arity) -1) (1- n))
|
||
(l '() (cons (frame-local-ref frame n) l)))
|
||
((< n 0) l))))
|
||
|
||
(define (frame-local-variables frame)
|
||
(let* ((prog (frame-program frame))
|
||
(arity (program-arity prog)))
|
||
(do ((n (+ (arity:nargs arity) (arity:nlocs arity) -1) (1- n))
|
||
(l '() (cons (frame-local-ref frame n) l)))
|
||
((< n 0) l))))
|
||
|
||
(define (frame-external-variables frame)
|
||
(frame-external-link frame))
|
||
|
||
(define (frame-external-ref frame index)
|
||
(list-ref (frame-external-link frame) index))
|
||
|
||
(define (frame-external-set! frame index val)
|
||
(list-set! (frame-external-link frame) index val))
|
||
|
||
(define (frame-binding-ref frame binding)
|
||
(if (binding:extp binding)
|
||
(frame-external-ref frame (binding:index binding))
|
||
(frame-local-ref frame (binding:index binding))))
|
||
|
||
(define (frame-binding-set! frame binding val)
|
||
(if (binding:extp binding)
|
||
(frame-external-set! frame (binding:index binding) val)
|
||
(frame-local-set! frame (binding:index binding) val)))
|
||
|
||
;; FIXME handle #f program-bindings return
|
||
(define (frame-bindings frame addr)
|
||
(filter (lambda (b) (and (>= addr (binding:start b))
|
||
(<= addr (binding:end b))))
|
||
(program-bindings (frame-program frame))))
|
||
|
||
(define (frame-lookup-binding frame addr sym)
|
||
(assq sym (reverse (frame-bindings frame addr))))
|
||
|
||
(define (frame-object-binding frame addr obj)
|
||
(do ((bs (frame-bindings frame addr) (cdr bs)))
|
||
((or (null? bs) (eq? obj (frame-binding-ref frame (car bs))))
|
||
(and (pair? bs) (car bs)))))
|
||
|
||
(define (frame-environment frame addr)
|
||
(map (lambda (binding)
|
||
(cons (binding:name binding) (frame-binding-ref frame binding)))
|
||
(frame-bindings frame addr)))
|
||
|
||
(define (frame-variable-exists? frame addr sym)
|
||
(if (frame-lookup-binding frame addr sym) #t #f))
|
||
|
||
(define (frame-variable-ref frame addr sym)
|
||
(cond ((frame-lookup-binding frame addr sym) =>
|
||
(lambda (binding) (frame-binding-ref frame binding)))
|
||
(else (error "Unknown variable:" sym))))
|
||
|
||
(define (frame-variable-set! frame addr sym val)
|
||
(cond ((frame-lookup-binding frame addr sym) =>
|
||
(lambda (binding) (frame-binding-set! frame binding val)))
|
||
(else (error "Unknown variable:" sym))))
|
||
|
||
(define (frame-object-name frame addr obj)
|
||
(cond ((frame-object-binding frame addr obj) => binding:name)
|
||
(else #f)))
|