1
Fork 0
mirror of https://git.savannah.gnu.org/git/guile.git synced 2025-04-30 03:40:34 +02:00
guile/gdbinit
Andy Wingo 53e28ed9b2 static opcodes; refactor program/objcode division; use new assembly pipeline
* 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.
2009-01-29 21:12:00 +01:00

202 lines
3.1 KiB
Text

# -*- GDB-Script -*-
define newline
call (void)scm_newline (scm_current_error_port ())
end
define pp
call (void)scm_call_1 (scm_variable_ref (scm_c_module_lookup (scm_c_resolve_module ("ice-9 pretty-print"), "pretty-print")), $arg0)
end
define gdisplay
call (void)scm_display ($arg0, scm_current_error_port ())
newline
end
define gwrite
call (void)scm_write ($arg0, scm_current_error_port ())
newline
end
define sputs
call (void)scm_puts ($arg0, scm_current_error_port ())
end
define gslot
print ((SCM**)$arg0)[1][$arg1]
end
define pslot
gslot $arg0 $arg1
gwrite $
end
define lforeach
set $l=$arg0
while $l != 0x404
set $x=scm_car($l)
$arg1 $x
set $l = scm_cdr($l)
end
end
define modsum
modname $arg0
gslot $arg0 1
set $uses=$
output "uses:\n"
lforeach $uses modname
end
define moduses
pslot $arg0 1
end
define modname
pslot $arg0 5
end
define modkind
pslot $arg0 6
end
define car
call scm_car ($arg0)
end
define cdr
call scm_cdr ($arg0)
end
define smobwordtox
set $x=((SCM*)$arg0)[$arg1]
end
define smobdatatox
smobwordtox $arg0 1
end
define program_objcode
smobdatatox $arg0
set $objcode=$x
smobdatatox $objcode
p *(struct scm_objcode*)$x
end
define proglocals
set $i=bp->nlocs
while $i > 0
set $i=$i-1
gwrite fp[bp->nargs+$i]
end
end
define progstack
set $x=sp
while $x > stack_base
gwrite *$x
set $x=$x-1
end
end
define tc16
p ((scm_t_bits)$arg0) & 0xffff
end
define smobdescriptor
p scm_smobs[0xff & (((scm_t_bits)$arg0) >> 8)]
end
define vmstackinit
set $vmsp=sp
set $vmstack_base=stack_base
set $vmfp=fp
set $vmbp=bp
set $vmframe=0
end
define nextframe
set $orig_vmsp=$vmsp
while $vmsp > $vmstack_base
output $orig_vmsp - $vmsp
sputs "\t"
output $vmsp
sputs "\t"
gwrite *$vmsp
set $vmsp=$vmsp-1
end
newline
sputs "Frame "
output $vmframe
newline
sputs "ra:\t"
output $vmsp
sputs "\t"
output (SCM*)*$vmsp
set $vmsp=$vmsp-1
newline
sputs "mvra:\t"
output $vmsp
sputs "\t"
output (SCM*)*$vmsp
set $vmsp=$vmsp-1
newline
sputs "dl:\t"
output $vmsp
sputs "\t"
set $vmdl=(SCM*)(*$vmsp)
output $vmdl
newline
set $vmsp=$vmsp-1
sputs "el:\t"
output $vmsp
sputs "\t"
gwrite *$vmsp
set $vmsp=$vmsp-1
set $vmnlocs=(int)$vmbp->nlocs
while $vmnlocs > 0
sputs "loc #"
output $vmnlocs
sputs ":\t"
output $vmsp
sputs "\t"
gwrite *$vmsp
set $vmsp=$vmsp-1
set $vmnlocs=$vmnlocs-1
end
set $vmnargs=(int)$vmbp->nargs
while $vmnargs > 0
sputs "arg #"
output $vmnargs
sputs ":\t"
output $vmsp
sputs "\t"
gwrite *$vmsp
set $vmsp=$vmsp-1
set $vmnargs=$vmnargs-1
end
sputs "prog:\t"
output $vmsp
sputs "\t"
gwrite *$vmsp
set $vmsp=$vmsp-1
newline
if $vmdl
set $vmfp=$vmdl
set $vmbp=(struct scm_objcode*)((SCM*)(((SCM*)($vmfp[-1]))[1])[1])
set $vmstack_base=$vmfp+$vmbp->nargs+$vmbp->nlocs+4
set $vmframe=$vmframe+1
newline
end
end
define vmstack
vmstackinit
while $vmsp > vp->stack_base
nextframe
end
end
define inst
p scm_instruction_table[$arg0]
end