Index: /branches/ia32/lisp-kernel/x86-constants32.s =================================================================== --- /branches/ia32/lisp-kernel/x86-constants32.s (revision 8067) +++ /branches/ia32/lisp-kernel/x86-constants32.s (revision 8068) @@ -1,13 +1,57 @@ +define([eax_l],[eax]) +define([ecx_l],[ecx]) +define([edx_l],[edx]) +define([ebx_l],[ebx]) +define([esi_l],[esi]) +define([edi_l],[edi]) + +define([eax_b],[al]) +define([ecx_b],[cl]) +define([edx_b],[dl]) +define([ebx_b],[bl]) + define([imm0],[eax]) + define([imm0_l],[eax]) + define([imm0_w],[ax]) + define([imm0_b],[al]) + define([Rimm0],[0]) + define([temp0],[ecx]) + define([temp0_l],[ecx]) + define([temp0_w],[cx]) + define([temp0_b],[cl]) + define([Rtemp0],[1]) + define([temp1],[edx]) + define([temp1_l],[edx]) + define([temp1_w],[dx]) + define([temp1_b],[dl]) + define([Rtemp1],[2]) + define([arg_z],[ebx]) + define([arg_z_l],[ebx]) + define([arg_z_w],[bx]) + define([arg_z_b],[bl]) + define([Rarg_z],[3]) + define([arg_y],[esi]) + define([Rarg_y],[6]) + define([fn],[edi]) + define([Rfn],[7]) define([rcontext],[fs]) - define([fname],[temp0]) define([allocptr],[temp0]) + +define([nargs_b],[imm0_b]) +define([nargs],[imm0_w]) +define([nargs_l],[imm0]) + +define([ra0],[temp0]) +define([xfn],[temp1]) + +define([allocptr],[temp0]) +define([stack_temp],[mm7]) define([fp0],[xmm0]) @@ -27,4 +71,5 @@ nfixnumtagbits = 2 num_subtag_bits = 8 +subtag_shift = num_subtag_bits fixnumshift = 2 fixnum_shift = 2 @@ -185,8 +230,4 @@ _node(foreign_sp) /* necessary? */ _node(db_link) /* head of special-binding chain */ - _node(_save3) /* saved nvrs (probably won't have any on IA-32 */ - _node(_save2) - _node(_save1) - _node(_save0) _node(xframe) /* exception frame chain */ _node(pc) /* TRA of catch exit or cleanup form */ @@ -431,8 +472,12 @@ _struct(tcr,TCR_BIAS) + _node(next) /* in doubly-linked list */ _node(prev) /* in doubly-linked list */ - _node(next) /* in doubly-linked list */ _word(node_regs_mask) _node(linear) /* our linear (non-segment-based) address. */ + _node(save0) /* spill area for node registers (16-byte aligned ) */ + _node(save1) + _node(save2) + _node(save3) _node(save_ebp) /* lisp EBP when in foreign code */ _word(lisp_mxcsr) @@ -447,5 +492,5 @@ _node(ts_area) /* tstack area pointer */ _node(cs_limit) /* cstack overflow limit */ - _word(bytes_consed_low) + _word(bytes_allocated) _word(bytes_consed_high) _node(log2_allocation_quantum) @@ -478,5 +523,4 @@ _node(next_tsp) _node(safe_ref_address) - _word(ldt_index) _word(ldt_selector) _ends @@ -496,2 +540,3 @@ INTERRUPT_LEVEL_BINDING_INDEX = fixnumone + Index: /branches/ia32/lisp-kernel/x86-spentry32.s =================================================================== --- /branches/ia32/lisp-kernel/x86-spentry32.s (revision 8067) +++ /branches/ia32/lisp-kernel/x86-spentry32.s (revision 8068) @@ -1,4 +1,3 @@ include(lisp.s) - _beginfile .align 2 @@ -6,10 +5,8 @@ .p2align 3 _exportfn(_SP$1) - .line __line__ ]) define([_endsubp],[ _endfn(_SP$1) -# __line__ ]) @@ -39,4 +36,57 @@ __(ret) _endsubp(fix_overflow) + +_spentry(misc_ref) + __(int $3) +_endsubp(misc_ref) + +_startfn(C(misc_ref_common)) + __(int $3) +_endfn(C(misc_ref_common)) + +_spentry(subtag_misc_ref) + __(int $3) +_endsubp(subtag_misc_ref) + +_spentry(subtag_misc_set) + __(int $3) +_endsubp(subtag_misc_set) + +_spentry(misc_set) + __(int $3) +_endsubp(misc_set) + +_startfn(C(misc_set_common)) + __(ret) +_endfn(C(misc_set_common)) + +_spentry(Fret1valn) + .globl C(ret1valn) +__(tra(C(ret1valn))) + __(mov (%esp),%ra0) + __(mov %arg_z,(%esp)) + __(set_nargs(1)) + __(jmp *%ra0) +_endsubp(Fret1valn) + +_spentry(nvalret) + .globl C(nvalret) +C(nvalret): + __(leave) + __(ret) +_endsubp(nvalret) + +_spentry(jmpsym) + __(jump_fname()) +_endsubp(jmpsym) + +_spentry(jmpnfn) + __(mov %temp0,%fn) + __(jmp *%fn) +_endsubp(jmpnfn) + +_spentry(funcall) + __(do_funcall()) +_endsubp(funcall) /* Make a lisp integer (fixnum or one-digit bignum) from the value in %imm0 */ @@ -59,5 +109,10 @@ 0: __(repret) _endsubp(makes32) - + +_spentry(makes64) + __(int $3) +_endsubp(makes64) + +/* xxx make lisp integer out of mm0 */ /* Make a lisp integer (probably a bignum) out of the %edx:%eax pair. */ /* We assume that the node_regs_mask in the TCR has been set to mark */ @@ -77,296 +132,583 @@ _endfn -/* %arg_y = uvector, %arg_z = index */ -/* subtag in %imm0.b */ -_startfn(C(misc_ref_common)) - .p2align 2 -local_label(misc_ref_jmp): - /* 00-0f */ - .long local_label(misc_ref_invalid) /* 00 even_fixnum */ - .long local_label(misc_ref_invalid) /* 01 cons */ - .long local_label(misc_ref_invalid) /* 02 nodeheader */ - .long local_label(misc_ref_invalid) /* 03 imm */ - .long local_label(misc_ref_invalid) /* 04 odd_fixnum */ - .long local_label(misc_ref_invalid) /* 05 tra */ - .long local_label(misc_ref_invalid) /* 06 misc */ - .long local_label(misc_ref_u32) /* 07 bignum */ - .long local_label(misc_ref_invalid) /* 08 even_fixnum */ - .long local_label(misc_ref_invalid) /* 09 cons */ - .long local_label(misc_ref_node) /* 0a ratio */ - .long local_label(misc_ref_invalid) /* 0b imm */ - .long local_label(misc_ref_invalid) /* 0c odd_fixnum */ - .long local_label(misc_ref_invalid) /* 0d nil */ - .long local_label(misc_ref_invalid) /* 0e misc */ - .long local_label(misc_ref_u32) /* 0f single_float */ - /* 10-1f */ - .long local_label(misc_ref_invalid) /* 10 even_fixnum */ - .long local_label(misc_ref_invalid) /* 11 cons */ - .long local_label(misc_ref_invalid) /* 12 nodeheader */ - .long local_label(misc_ref_invalid) /* 13 imm */ - .long local_label(misc_ref_invalid) /* 14 odd_fixnum */ - .long local_label(misc_ref_invalid) /* 15 tra */ - .long local_label(misc_ref_invalid) /* 16 misc */ - .long local_label(misc_ref_u32) /* 17 double_float */ - .long local_label(misc_ref_invalid) /* 18 even_fixnum */ - .long local_label(misc_ref_invalid) /* 19 cons */ - .long local_label(misc_ref_node) /* 1a complex */ - .long local_label(misc_ref_invalid) /* 1b imm */ - .long local_label(misc_ref_invalid) /* 1c odd_fixnum */ - .long local_label(misc_ref_invalid) /* 1d nil */ - .long local_label(misc_ref_invalid) /* 1e misc */ - .long local_label(misc_ref_u32) /* 1f macptr */ - /* 20-2f */ - .long local_label(misc_ref_invalid) /* 20 even_fixnum */ - .long local_label(misc_ref_invalid) /* 21 cons */ - .long local_label(misc_ref_node) /* 22 catch_frame */ - .long local_label(misc_ref_invalid) /* 23 imm */ - .long local_label(misc_ref_invalid) /* 24 odd_fixnum */ - .long local_label(misc_ref_invalid) /* 25 tra */ - .long local_label(misc_ref_invalid) /* 26 misc */ - .long local_label(misc_ref_u32) /* 27 dead_macptr */ - .long local_label(misc_ref_invalid) /* 28 even_fixnum */ - .long local_label(misc_ref_invalid) /* 29 cons */ - .long local_label(misc_ref_node) /* 2a function */ - .long local_label(misc_ref_invalid) /* 2b imm */ - .long local_label(misc_ref_invalid) /* 2c odd_fixnum */ - .long local_label(misc_ref_invalid) /* 2d nil */ - .long local_label(misc_ref_invalid) /* 2e misc */ - .long local_label(misc_ref_u32) /* 2f code_vector */ - /* 30-3f */ - .long local_label(misc_ref_invalid) /* 30 even_fixnum */ - .long local_label(misc_ref_invalid) /* 31 cons */ - .long local_label(misc_ref_node) /* 32 lisp_thread */ - .long local_label(misc_ref_invalid) /* 33 imm */ - .long local_label(misc_ref_invalid) /* 34 odd_fixnum */ - .long local_label(misc_ref_invalid) /* 35 tra */ - .long local_label(misc_ref_invalid) /* 36 misc */ - .long local_label(misc_ref_u32) /* 37 creole */ - .long local_label(misc_ref_invalid) /* 38 even_fixnum */ - .long local_label(misc_ref_invalid) /* 39 cons */ - .long local_label(misc_ref_node) /* 3a symbol */ - .long local_label(misc_ref_invalid) /* 3b imm */ - .long local_label(misc_ref_invalid) /* 3c odd_fixnum */ - .long local_label(misc_ref_invalid) /* 3d nil */ - .long local_label(misc_ref_invalid) /* 3e misc */ - .long local_label(misc_ref_u32) /* 3f xcode_vector */ - /* 40-4f */ - .long local_label(misc_ref_invalid) /* 40 even_fixnum */ - .long local_label(misc_ref_invalid) /* 41 cons */ - .long local_label(misc_ref_node) /* 42 lock */ - .long local_label(misc_ref_invalid) /* 43 imm */ - .long local_label(misc_ref_invalid) /* 44 odd_fixnum */ - .long local_label(misc_ref_invalid) /* 45 tra */ - .long local_label(misc_ref_invalid) /* 46 misc */ - .long local_label(misc_ref_invalid) /* 47 immheader */ - .long local_label(misc_ref_invalid) /* 48 even_fixnum */ - .long local_label(misc_ref_invalid) /* 49 cons */ - .long local_label(misc_ref_node) /* 4a hash_vector */ - .long local_label(misc_ref_invalid) /* 4b imm */ - .long local_label(misc_ref_invalid) /* 4c odd_fixnum */ - .long local_label(misc_ref_invalid) /* 4d tra */ - .long local_label(misc_ref_invalid) /* 4e misc */ - .long local_label(misc_ref_invalid) /* 4f immheader */ - /* 50-5f */ - .long local_label(misc_ref_invalid) /* 50 even_fixnum */ - .long local_label(misc_ref_invalid) /* 51 cons */ - .long local_label(misc_ref_node) /* 52 pool */ - .long local_label(misc_ref_invalid) /* 53 imm */ - .long local_label(misc_ref_invalid) /* 54 odd_fixnum */ - .long local_label(misc_ref_invalid) /* 55 tra */ - .long local_label(misc_ref_invalid) /* 56 misc */ - .long local_label(misc_ref_invalid) /* 57 immheader */ - .long local_label(misc_ref_invalid) /* 58 even_fixnum */ - .long local_label(misc_ref_invalid) /* 59 cons */ - .long local_label(misc_ref_node) /* 5a weak */ - .long local_label(misc_ref_invalid) /* 5b imm */ - .long local_label(misc_ref_invalid) /* 5c odd_fixnum */ - .long local_label(misc_ref_invalid) /* 5d nil */ - .long local_label(misc_ref_invalid) /* 5e misc */ - .long local_label(misc_ref_invalid) /* 5f immheader */ - /* 60-6f */ - .long local_label(misc_ref_invalid) /* 60 even_fixnum */ - .long local_label(misc_ref_invalid) /* 61 cons */ - .long local_label(misc_ref_node) /* 62 package */ - .long local_label(misc_ref_invalid) /* 63 imm */ - .long local_label(misc_ref_invalid) /* 64 odd_fixnum */ - .long local_label(misc_ref_invalid) /* 65 tra */ - .long local_label(misc_ref_invalid) /* 66 misc */ - .long local_label(misc_ref_invalid) /* 67 immheader */ - .long local_label(misc_ref_invalid) /* 68 even_fixnum */ - .long local_label(misc_ref_invalid) /* 69 cons */ - .long local_label(misc_ref_node) /* 6a slot_vector */ - .long local_label(misc_ref_invalid) /* 6b imm */ - .long local_label(misc_ref_invalid) /* 6c odd_fixnum */ - .long local_label(misc_ref_invalid) /* 6d tra */ - .long local_label(misc_ref_invalid) /* 6e misc */ - .long local_label(misc_ref_invalid) /* 6f immheader */ - /* 70-7f */ - .long local_label(misc_ref_invalid) /* 70 even_fixnum */ - .long local_label(misc_ref_invalid) /* 71 cons */ - .long local_label(misc_ref_node) /* 72 instance */ - .long local_label(misc_ref_invalid) /* 73 imm */ - .long local_label(misc_ref_invalid) /* 74 odd_fixnum */ - .long local_label(misc_ref_invalid) /* 75 tra */ - .long local_label(misc_ref_invalid) /* 76 misc */ - .long local_label(misc_ref_invalid) /* 77 immheader */ - .long local_label(misc_ref_invalid) /* 78 even_fixnum */ - .long local_label(misc_ref_invalid) /* 79 cons */ - .long local_label(misc_ref_node) /* 7a struct */ - .long local_label(misc_ref_invalid) /* 7b imm */ - .long local_label(misc_ref_invalid) /* 7c odd_fixnum */ - .long local_label(misc_ref_invalid) /* 7d tra */ - .long local_label(misc_ref_invalid) /* 7e misc */ - .long local_label(misc_ref_invalid) /* 7f immheader */ - /* 80-8f */ - .long local_label(misc_ref_invalid) /* 80 even_fixnum */ - .long local_label(misc_ref_invalid) /* 81 cons */ - .long local_label(misc_ref_node) /* 82 istruct */ - .long local_label(misc_ref_invalid) /* 83 imm */ - .long local_label(misc_ref_invalid) /* 84 odd_fixnum */ - .long local_label(misc_ref_invalid) /* 85 tra */ - .long local_label(misc_ref_invalid) /* 86 misc */ - .long local_label(misc_ref_invalid) /* 87 immheader */ - .long local_label(misc_ref_invalid) /* 88 even_fixnum */ - .long local_label(misc_ref_invalid) /* 89 cons */ - .long local_label(misc_ref_node) /* 8a value_cell */ - .long local_label(misc_ref_invalid) /* 8b imm */ - .long local_label(misc_ref_invalid) /* 8c odd_fixnum */ - .long local_label(misc_ref_invalid) /* 8d tra */ - .long local_label(misc_ref_invalid) /* 8e misc */ - .long local_label(misc_ref_invalid) /* 8f immheader */ - /* 90-9f */ - .long local_label(misc_ref_invalid) /* 90 even_fixnum */ - .long local_label(misc_ref_invalid) /* 91 cons */ - .long local_label(misc_ref_node) /* 92 xfunction */ - .long local_label(misc_ref_invalid) /* 93 imm */ - .long local_label(misc_ref_invalid) /* 94 odd_fixnum */ - .long local_label(misc_ref_invalid) /* 95 tra */ - .long local_label(misc_ref_invalid) /* 96 misc */ - .long local_label(misc_ref_invalid) /* 97 immheader */ - .long local_label(misc_ref_invalid) /* 98 even_fixnum */ - .long local_label(misc_ref_invalid) /* 99 cons */ - .long local_label(misc_ref_node) /* 9a arrayN */ - .long local_label(misc_ref_invalid) /* 9b imm */ - .long local_label(misc_ref_invalid) /* 9c odd_fixnum */ - .long local_label(misc_ref_invalid) /* 9d tra */ - .long local_label(misc_ref_invalid) /* 9e misc */ - .long local_label(misc_ref_invalid) /* 9f immheader */ - /* a0-af */ - .long local_label(misc_ref_invalid) /* a0 even_fixnum */ - .long local_label(misc_ref_invalid) /* a1 cons */ - .long local_label(misc_ref_node) /* a2 vectorH */ - .long local_label(misc_ref_invalid) /* a3 imm */ - .long local_label(misc_ref_invalid) /* a4 odd_fixnum */ - .long local_label(misc_ref_invalid) /* a5 tra */ - .long local_label(misc_ref_invalid) /* a6 misc */ - .long local_label(misc_ref_single_float_vector) /* a7 sf_vector */ - .long local_label(misc_ref_invalid) /* a8 even_fixnum */ - .long local_label(misc_ref_invalid) /* a9 cons */ - .long local_label(misc_ref_node) /* aa simple_vector */ - .long local_label(misc_ref_invalid) /* ab imm */ - .long local_label(misc_ref_invalid) /* ac odd_fixnum */ - .long local_label(misc_ref_invalid) /* ad tra */ - .long local_label(misc_ref_invalid) /* ae misc */ - .long local_label(misc_ref_u32) /* af u32 */ - /* b0-bf */ - .long local_label(misc_ref_invalid) /* b0 even_fixnum */ - .long local_label(misc_ref_invalid) /* b1 cons */ - .long local_label(misc_ref_invalid) /* b2 nodeheader */ - .long local_label(misc_ref_invalid) /* b3 imm */ - .long local_label(misc_ref_invalid) /* b4 odd_fixnum */ - .long local_label(misc_ref_invalid) /* b5 tra */ - .long local_label(misc_ref_invalid) /* b6 misc */ - .long local_label(misc_ref_s32) /* b7 s32 */ - .long local_label(misc_ref_invalid) /* b8 even_fixnum */ - .long local_label(misc_ref_invalid) /* b9 cons */ - .long local_label(misc_ref_invalid) /* ba nodeheader */ - .long local_label(misc_ref_invalid) /* bb imm */ - .long local_label(misc_ref_invalid) /* bc odd_fixnum */ - .long local_label(misc_ref_invalid) /* bd tra */ - .long local_label(misc_ref_invalid) /* be misc */ - .long local_label(misc_ref_fixnum_vector) /* bf fixnum_vector */ - /* c0-cf */ - .long local_label(misc_ref_invalid) /* c0 even_fixnum */ - .long local_label(misc_ref_invalid) /* c1 cons */ - .long local_label(misc_ref_invalid) /* c2 nodeheader */ - .long local_label(misc_ref_invalid) /* c3 imm */ - .long local_label(misc_ref_invalid) /* c4 odd_fixnum */ - .long local_label(misc_ref_invalid) /* c5 tra */ - .long local_label(misc_ref_invalid) /* c6 misc */ - .long local_label(misc_ref_new_string) /* c7 new_string */ - .long local_label(misc_ref_invalid) /* c8 even_fixnum */ - .long local_label(misc_ref_invalid) /* c9 cons */ - .long local_label(misc_ref_invalid) /* ca nodeheader */ - .long local_label(misc_ref_invalid) /* cb imm */ - .long local_label(misc_ref_invalid) /* cc odd_fixnum */ - .long local_label(misc_ref_invalid) /* cd tra */ - .long local_label(misc_ref_invalid) /* ce misc */ - .long local_label(misc_ref_u8) /* cf u8 */ - /* d0-df */ - .long local_label(misc_ref_invalid) /* d0 even_fixnum */ - .long local_label(misc_ref_invalid) /* d1 cons */ - .long local_label(misc_ref_invalid) /* d2 nodeheader */ - .long local_label(misc_ref_invalid) /* d3 imm */ - .long local_label(misc_ref_invalid) /* d4 odd_fixnum */ - .long local_label(misc_ref_invalid) /* d5 tra */ - .long local_label(misc_ref_invalid) /* d6 misc */ - .long local_label(misc_ref_s8) /* d7 s8 */ - .long local_label(misc_ref_invalid) /* d8 even_fixnum */ - .long local_label(misc_ref_invalid) /* d9 cons */ - .long local_label(misc_ref_invalid) /* da nodeheader */ - .long local_label(misc_ref_invalid) /* db imm */ - .long local_label(misc_ref_invalid) /* dc odd_fixnum */ - .long local_label(misc_ref_invalid) /* dd tra */ - .long local_label(misc_ref_invalid) /* de misc */ - .long local_label(misc_ref_old_string) /* df (old)subtag_simple_base_string */ - /* e0-ef */ - .long local_label(misc_ref_invalid) /* e0 even_fixnum */ - .long local_label(misc_ref_invalid) /* e1 cons */ - .long local_label(misc_ref_invalid) /* e2 nodeheader */ - .long local_label(misc_ref_invalid) /* e3 imm */ - .long local_label(misc_ref_invalid) /* e4 odd_fixnum */ - .long local_label(misc_ref_invalid) /* e5 tra */ - .long local_label(misc_ref_invalid) /* e6 misc */ - .long local_label(misc_ref_u16) /* e7 u16 */ - .long local_label(misc_ref_invalid) /* e8 even_fixnum */ - .long local_label(misc_ref_invalid) /* e9 cons */ - .long local_label(misc_ref_invalid) /* ea nodeheader */ - .long local_label(misc_ref_invalid) /* eb imm */ - .long local_label(misc_ref_invalid) /* ec odd_fixnum */ - .long local_label(misc_ref_invalid) /* ed tra */ - .long local_label(misc_ref_invalid) /* ee misc */ - .long local_label(misc_ref_s16) /* ef s16 */ - /* f0-ff */ - .long local_label(misc_ref_invalid) /* f0 even_fixnum */ - .long local_label(misc_ref_invalid) /* f1 cons */ - .long local_label(misc_ref_invalid) /* f2 nodeheader */ - .long local_label(misc_ref_invalid) /* f3 imm */ - .long local_label(misc_ref_invalid) /* f4 odd_fixnum */ - .long local_label(misc_ref_invalid) /* f5 tra */ - .long local_label(misc_ref_invalid) /* f6 misc */ - .long local_label(misc_ref_double_float_vector) /* f7 df vector */ - .long local_label(misc_ref_invalid) /* f8 even_fixnum */ - .long local_label(misc_ref_invalid) /* f9 cons */ - .long local_label(misc_ref_invalid) /* fa nodeheader */ - .long local_label(misc_ref_invalid) /* fb imm */ - .long local_label(misc_ref_invalid) /* fc odd_fixnum */ - .long local_label(misc_ref_invalid) /* fd tra */ - .long local_label(misc_ref_invalid) /* fe misc */ - .long local_label(misc_ref_bit_vector) /* ff bit_vector */ -local_label(misc_ref_invalid): + +_spentry(syscall) + /* Save lisp registers */ + __(push %ebp) + __(movl %esp,%ebp) + __(push %temp0) + __(push %temp1) + __(push %arg_y) + __(push %arg_z) + __(push %fn) + __(movl %esp,%rcontext:tcr.save_vsp) + __(movl %ebp,%rcontext:tcr.save_ebp) + __(movl $TCR_STATE_FOREIGN,%rcontext:tcr.valence) + __(movl %rcontext:tcr.foreign_sp,%esp) + __(emms) + __(movl (%esp),%ebp) + __(addl $2*node_size,%esp) + __(unbox_fixnum(%arg_z,%eax)) + /* push syscall args on stack */ + __(int $0x80) + __(movl %ebp,%esp) + __(movl %esp,%rcontext:tcr.foreign_sp) + __(zero_node_regs) + __(pxor %fpzero,%fpzero) + __(movl %rcontext:tcr.save_vsp,%esp) + __(movl %rcontext:tcr.save_ebp,%ebp) + __(movl $TCR_STATE_LISP,%rcontext:tcr.valence) + __(pop %fn) + __(pop %arg_z) + __(pop %arg_y) + __(pop %temp1) + __(check_pending_interrupt(%temp0)) + __(push %temp0) + __(leave) + __(ret) +_endsubp(syscall) + +_spentry(mkcatch1v) + __(nMake_Catch(0)) + __(ret) +_endsubp(mkcatch1v) + +_spentry(mkunwind) + __(int $3) +_endsubp(mkunwind) + +/* this takes a return address in %ra0; it's "new" in that it does the */ +/* double binding of *interrupt-level* out-of-line */ +_spentry(nmkunwind) + __(int $3) +_endsubp(nmkunwind) + +_spentry(mkcatchmv) + __(int $3) +_endsubp(mkcatchmv) + +_spentry(throw) + __(int $3) +_endsubp(throw) + +/* This takes N multiple values atop the vstack. */ +_spentry(nthrowvalues) + __(int $3) +_endsubp(nthrowvalues) + +/* This is a (slight) optimization. When running an unwind-protect, */ +/* save the single value and the throw count in the tstack frame. */ +/* Note that this takes a single value in arg_z. */ + +_spentry(nthrow1value) + __(int $3) +_endsubp(nthrow1value) + +/* This never affects the symbol's vcell */ +/* Non-null symbol in arg_y, new value in arg_z */ + +_spentry(bind) + __(int $3) +_endsubp(bind) + +/* arg_z = symbol: bind it to its current value */ + +_spentry(bind_self) + __(int $3) +_endsubp(bind_self) + +_spentry(bind_nil) + __(int $3) +_endsubp(bind_nil) + +_spentry(bind_self_boundp_check) + __(int $3) +_endsubp(bind_self_boundp_check) + +_spentry(conslist) + __(int $3) +_endsubp(conslist) + +/* do list*: last arg in arg_z, all others pushed, nargs set to #args pushed. */ +/* Cons, one cons cell at at time. Maybe optimize this later. */ + +_spentry(conslist_star) + __(int $3) +_endsubp(conslist_star) + +/* We always have to create a tsp frame (even if nargs is 0), so the compiler */ +/* doesn't get confused. */ +_spentry(stkconslist) + __(int $3) +_endsubp(stkconslist) + +/* do list*: last arg in arg_z, all others vpushed, */ +/* nargs set to #args vpushed. */ + +_spentry(stkconslist_star) + __(int $3) +_endsubp(stkconslist_star) + + +/* Make a stack-consed simple-vector out of the NARGS objects */ +/* on top of the vstack; return it in arg_z. */ + +_spentry(mkstackv) + __(int $3) +_endsubp(mkstackv) + + .globl C(egc_write_barrier_start) +C(egc_write_barrier_start): +/* */ +/* The function pc_luser_xp() - which is used to ensure that suspended threads */ +/* are suspended in a GC-safe way - has to treat these subprims (which implement */ +/* the EGC write-barrier) specially. Specifically, a store that might introduce */ +/* an intergenerational reference (a young pointer stored in an old object) has */ +/* to "memoize" that reference by setting a bit in the global "refbits" bitmap. */ +/* This has to happen atomically, and has to happen atomically wrt GC. */ + +/* Note that updating a word in a bitmap is itself not atomic, unless we use */ +/* interlocked loads and stores. */ + +/* For RPLACA and RPLACD, things are fairly simple: regardless of where we are */ +/* in the function, we can do the store (even if it's already been done) and */ +/* calculate whether or not we need to set the bit out-of-line. (Actually */ +/* setting the bit needs to be done atomically, unless we're sure that other */ +/* threads are suspended.) */ +/* We can unconditionally set the suspended thread's RIP to the return address. */ + +_spentry(rplaca) + .globl C(egc_rplaca) +C(egc_rplaca): + __(int $3) +_endsubp(rplaca) + +_spentry(rplacd) + .globl C(egc_rplacd) +C(egc_rplacd): + __(int $3) +_endsubp(rplacd) + +_spentry(gvset) + .globl C(egc_gvset) +C(egc_gvset): + __(int $3) +_endsubp(gvset) + +_spentry(set_hash_key) + .globl C(egc_set_hash_key) +C(egc_set_hash_key): + __(int $3) +_endsubp(set_hash_key) + +/* This is a little trickier: if this is interrupted, we need to know */ +/* whether or not the STORE-CONDITIONAL (cmpxchgq) has won or not. */ +/* If we're interrupted before the PC has reached the "success_test" label, */ +/* repeat (luser the PC back to .SPstore_node_conditional.) If we're at that */ +/* label with the Z flag set, we won and (may) need to memoize. */ + +_spentry(store_node_conditional) + .globl C(egc_store_node_conditional) +C(egc_store_node_conditional): + .globl C(egc_store_node_conditional_success_test) +C(egc_store_node_conditional_success_test): + .globl C(egc_write_barrier_end) +C(egc_write_barrier_end): + __(int $3) +_endsubp(store_node_conditional) + +_spentry(setqsym) + __(bt $sym_vbit_const,symbol.flags(%arg_y)) + __(jae _SPspecset) + __(mov %arg_y,%arg_z) + __(mov $XCONST,%arg_y) + __(set_nargs(2)) __(jmp _SPksignalerr) -local_label(misc_ref_u32): - __(movl misc_data_offset(%arg_y,%arg_z),%imm0) - __(jmp _SPmakeu32) - __(ret) -local_label(misc_ref_node): - __(movl misc_data_offset(%arg_y,%arg_z),%arg_z) - __(ret) -local_label(misc_ref_single_float_vector): -local_label(misc_ref_s32): -local_label(misc_ref_fixnum_vector): -local_label(misc_ref_new_string): -local_label(misc_ref_u8): -local_label(misc_ref_s8): +_endsubp(setqsym) + +_spentry(progvsave) + __(int $3) +_endsubp(progvsave) + +/* Allocate node objects on the temp stack, immediate objects on the foreign */ +/* stack. (The caller has to know which stack to discard a frame from.) */ +/* %arg_y = boxed element-count, %arg_z = boxed subtype */ + +_spentry(stack_misc_alloc) + __(int $3) +_endsubp(stack_misc_alloc) + +/* subtype (boxed, of course) is pushed, followed by nargs bytes worth of */ +/* initial-contents. Note that this can be used to cons any type of initialized */ +/* node-header'ed misc object (symbols, closures, ...) as well as vector-like */ +/* objects. */ +_spentry(gvector) + __(int $3) +_endsubp(gvector) + +_spentry(mvpass) + __(int $3) +_endsubp(mvpass) + +_spentry(nthvalue) + __(int $3) +_endsubp(nthvalue) + +_spentry(values) + __(int $3) +_endsubp(values) + +_spentry(default_optional_args) + __(int $3) +_endsubp(default_optional_args) + +_spentry(opt_supplied_p) + __(int $3) +_endsubp(opt_supplied_p) + +_spentry(lexpr_entry) + __(int $3) +_endsubp(lexpr_entry) + +_spentry(heap_rest_arg) + __(int $3) +_endsubp(heap_rest_arg) + +/* %imm0 contains the number of fixed args ; make an &rest arg out of the others */ +_spentry(req_heap_rest_arg) + __(int $3) +_endsubp(req_heap_rest_arg) + +/* %imm0 bytes of stuff has already been pushed */ +/* make an &rest arg out of any others */ +_spentry(heap_cons_rest_arg) + __(int $3) +_endsubp(heap_cons_rest_arg) + +_spentry(simple_keywords) + __(xor %imm0,%imm0) + __(push_argregs()) + __(jmp _SPkeyword_bind) +_endsubp(simple_keywords) + +_spentry(keyword_args) + __(push_argregs()) + __(jmp _SPkeyword_bind) +_endsubp(keyword_args) + +/* There are %nargs words of arguments on the stack; %imm0 contains the number */ +/* of non-keyword args pushed. It's possible that we never actually got */ +/* any keyword args, which would make things much simpler. */ + +/* On entry, temp1 contains a fixnum with bits indicating whether */ +/* &allow-other-keys and/or &rest was present in the lambda list. */ +/* Once we get here, we can use the arg registers. */ + +define([keyword_flags_aok_bit],[fixnumshift]) +define([keyword_flags_unknown_keys_bit],[fixnumshift+1]) +define([keyword_flags_rest_bit],[fixnumshift+2]) +define([keyword_flags_seen_aok_bit],[fixnumshift+3]) + +_spentry(keyword_bind) + __(int $3) +_endsubp(keyword_bind) + +_spentry(ksignalerr) + __(mov $nrs.errdisp,%fname) + __(jump_fname) +_endsubp(ksignalerr) + +_spentry(stack_rest_arg) + __(xorl %imm0,%imm0) + __(push_argregs()) + __(jmp _SPstack_cons_rest_arg) +_endsubp(stack_rest_arg) + +_spentry(req_stack_rest_arg) + __(push_argregs()) + __(jmp _SPstack_cons_rest_arg) +_endsubp(req_stack_rest_arg) + +_spentry(stack_cons_rest_arg) +_endsubp(stack_cons_rest_arg) + +_spentry(getxlong) + __(int $3) +_endsubp(getxlong) + +/* Have to be a little careful here: the caller may or may not have pushed */ +/* an empty frame, and we may or may not have needed one. We can't easily */ +/* tell whether or not a frame will be needed (if the caller didn't reserve */ +/* a frame, whether or not we need one depends on the length of the list */ +/* in arg_z. So, if the caller didn't push a frame, we do so ; once everything's */ +/* been spread, we discard the reserved frame (regardless of who pushed it) */ +/* if all args fit in registers. */ +_spentry(spreadargz) + __(int $3) +_endsubp(spreadargz) + + +/* Caller built it's own frame when it was entered. If all outgoing args */ +/* are in registers, we can discard that frame; otherwise, we copy outgoing */ +/* relative to it and restore %rbp/%ra0 */ +_spentry(tfuncallgen) + __(int $3) +_endsubp(tfuncallgen) + +/* Some args were pushed; move them down in the frame */ +_spentry(tfuncallslide) + __(int $3) +_endsubp(tfuncallslide) + +/* No args were pushed; recover saved context & do funcall */ +_spentry(tfuncallvsp) + __(leave) + __(do_funcall()) +_endsubp(tfuncallvsp) + +_spentry(tcallsymgen) + __(int $3) +_endsubp(tcallsymgen) + +_spentry(tcallsymslide) + __(int $3) +_endsubp(tcallsymslide) + +_spentry(tcallsymvsp) + __(leave) + __(jump_fname()) +_endsubp(tcallsymvsp) + +_spentry(tcallnfngen) + __(int $3) +_endsubp(tcallnfngen) + +_spentry(tcallnfnslide) + __(int $3) +_endsubp(tcallnfnslide) + +_spentry(tcallnfnvsp) + __(mov %temp0,%fn) + __(leave) + __(jmp *%fn) +_endsubp(tcallnfnvsp) + +_spentry(makestackblock) + __(int $3) +_endsubp(makestackblock) + +_spentry(makestackblock0) + __(int $3) +_endsubp(makestackblock0) + +_spentry(makestacklist) + __(int $3) +_endsubp(makestacklist) + +_spentry(stkgvector) + __(int $3) +_endsubp(stkgvector) + +_spentry(misc_alloc) + __(int $3) +_endsubp(misc_alloc) + +_startfn(C(destbind1)) + __(jmp *%ra0) +_endfn(C(destbind1)) + +_spentry(macro_bind) + __(int $3) +_endsubp(macro_bind) + +_spentry(destructuring_bind) + __(mov %arg_reg,%whole_reg) + __(jmp C(destbind1)) +_endsubp(destructuring_bind) + +_spentry(destructuring_bind_inner) + __(mov %arg_z,%whole_reg) + __(jmp C(destbind1)) +_endsubp(destructuring_bind_inner) + +_spentry(vpopargregs) + __(int $3) +_endsubp(vpopargregs) + +/* If arg_z is an integer, return in imm0 something whose sign */ +/* is the same as arg_z's. If not an integer, error. */ +_spentry(integer_sign) + __(testb $tagmask,%arg_z_b) + __(mov %arg_z,%imm0) + __(je 8f) + __(extract_typecode(%arg_z,%imm0)) + __(cmpb $subtag_bignum,%imm0_b) + __(jne 9f) + __(getvheader(%arg_z,%imm0)) + __(shr $num_subtag_bits,%imm0) + __(movl misc_data_offset-4(%arg_z,%imm0,4),%imm0) +8: __(repret) +9: __(uuo_error_reg_not_type(Rarg_z,error_object_not_integer)) +_endsubp(integer_sign) + +_spentry(mvslide) + __(int $3) +_endsubp(mvslide) + +_spentry(save_values) + __(int $3) +_endsubp(save_values) + +_spentry(add_values) + __(int $3) +_endsubp(add_values) + +_spentry(recover_values) + __(int $3) +_endsubp(recover_values) + +_spentry(recover_values_for_mvcall) + __(int $3) +_endsubp(recover_values_for_mvcall) + +_spentry(reset) + __(int $3) +_endsubp(reset) + +_spentry(misc_alloc_init) + __(int $3) +_endsubp(misc_alloc_init) + +_spentry(stack_misc_alloc_init) + __(int $3) +_endsubp(stack_misc_alloc_init) + + .globl C(popj) +_spentry(popj) +C(popj): + __(leave) + __(ret) +_endsubp(popj) + + +_spentry(gets64) + __(int $3) +_endsubp(gets64) + + +/* arg_z should be of type (unsigned-byte 64) */ +/* return unboxed value in mm0 */ +_spentry(getu64) + __(movl $~(target_most_positive_fixnum << fixnumshift),%imm0) + __(testl %arg_z,%imm0) + __(movl %arg_z,%imm0) + __(jne 1f) + __(sarl $fixnumshift,%imm0) + __(movd %imm0,%mm0) + __(ret) +1: __(andb $tagmask,%imm0_b) + __(cmpb $tag_misc,%imm0_b) + __(jne 9f) + __(movb misc_subtag_offset(%arg_z),%imm0_b) + __(cmpb $subtag_bignum,%imm0_b) + __(jne 9f) + __(movl misc_header_offset(%arg_z),%imm0) + __(cmpl $three_digit_bignum_header,%imm0) + __(je 3f) + __(cmpl $two_digit_bignum_header,%imm0) + __(jne 9f) + __(movl misc_data_offset(%arg_z),%imm0) + __(testl %imm0,%imm0) + __(js 9f) + __(repret) +3: __(movl misc_data_offset(%arg_z),%imm0) + __(cmpl $0,misc_data_offset+8(%arg_z)) + __(jne 9f) + __(repret) +9: __(uuo_error_reg_not_type(Rarg_z,error_object_not_u64)) +_endsubp(getu64) + +_spentry(makeu64) + __(int $3) +_endsubp(makeu64) + +_spentry(specref) + __(int $3) +_endsubp(specref) + +_spentry(specset) + __(int $3) +_endsubp(specset) + +_spentry(specrefcheck) + __(int $3) +_endsubp(specrefcheck) + +_spentry(restoreintlevel) + __(int $3) +_endsubp(restoreintlevel) + +_spentry(makeu32) + __(int $3) +_endsubp(makeu32) + +_spentry(gets32) + __(int $3) +_endsubp(gets32) + +_spentry(getu32) + __(int $3) +_endsubp(getu32) + +_spentry(mvpasssym) + __(int $3) +_endsubp(mvpasssym) + +_spentry(unbind) + __(int $3) +_endsubp(unbind) + +_spentry(unbind_n) + __(int $3) +_endsubp(unbind_n) + +_spentry(unbind_to) + __(int $3) +_endsubp(unbind_to) + +_spentry(bind_interrupt_level_0) + __(int $3) +_endsubp(bind_interrupt_level_0) + +_spentry(bind_interrupt_level_m1) + __(int $3) +_endsubp(bind_interrupt_level_m1) + +_spentry(bind_interrupt_level) + __(int $3) +_endsubp(bind_interrupt_level) + +_spentry(unbind_interrupt_level) + __(int $3) +_endsubp(unbind_interrupt_level) + +_spentry(progvrestore) + __(int $3) +_endsubp(progvrestore) + +_spentry(builtin_plus) + __(int $3) +_endsubp(builtin_plus) + +_spentry(builtin_minus) + __(int $3) +_endsubp(builtin_minus) + +_spentry(builtin_times) + __(int $3) +_endsubp(builtin_times) + +_spentry(builtin_div) + __(jump_builtin(_builtin_div,2)) /* %arg_z <- (= %arg_y %arg_z). */ @@ -420,5 +762,5 @@ /* %arg_z <- (< %arg_y %arg_z). */ _spentry(builtin_lt) - __(movl %arg_y,%imm0_b) + __(movl %arg_y,%imm0) __(orb %arg_z_b,%imm0_b) __(testb $fixnummask,%imm0_b) @@ -442,4 +784,30 @@ _endsubp(builtin_le) +_spentry(builtin_eql) + __(int $3) +_endsubp(builtin_eql) + +_spentry(builtin_length) + __(int $3) +_endsubp(builtin_length) + +_spentry(builtin_seqtype) + __(int $3) +_endsubp(builtin_seqtype) + +_spentry(builtin_assq) + __(int $3) +_endsubp(builtin_assq) + +_spentry(builtin_memq) + __(int $3) +_endsubp(builtin_memq) + +logbitp_max_bit = 30 + +_spentry(builtin_logbitp) + __(int $3) +_endsubp(builtin_logbitp) + _spentry(builtin_logior) __(movl %arg_y,%imm0) @@ -451,5 +819,4 @@ 1: __(jump_builtin(_builtin_logior,2)) - _endsubp(builtin_logior) @@ -485,2 +852,136 @@ __(jump_builtin(_builtin_logxor,2)) _endsubp(builtin_logxor) + +_spentry(builtin_aset1) + __(int $3) +_endsubp(builtin_aset1) + +_spentry(builtin_ash) + __(int $3) +_endsubp(builtin_ash) + +_spentry(builtin_aref1) + __(extract_typecode(%arg_y,%imm0)) + __(cmpb $min_vector_subtag,%imm0_b) + __(box_fixnum_no_flags(%imm0,%arg_y)) + __(ja _SPsubtag_misc_ref) + __(jump_builtin(_builtin_aref1,2)) +_endsubp(builtin_aref1) + +_spentry(ffcall) + __(int $3) +_endsubp(ffcall) + +_spentry(ffcall_return_registers) + __(int $3) +_endsubp(ffcall_return_registers) + +_spentry(spread_lexprz) + __(int $3) +_endsubp(spread_lexprz) + +_spentry(callback) + __(int $3) +_endsubp(callback) + +_spentry(aref2) + __(int $3) +_endsubp(aref2) + +_spentry(aref3) + __(int $3) +_endsubp(aref3) + +_spentry(aset2) + __(int $3) +_endsubp(aset2) + +_spentry(aset3) + __(int $3) +_endsubp(aset3) + +_spentry(call_closure) + __(int $3) +_endsubp(call_closure) + +_spentry(poweropen_callbackX) + __(int $3) +_endsubp(poweropen_callbackX) + +_spentry(poweropen_ffcallX) + __(int $3) +_endsubp(poweropen_ffcallX) + +_spentry(poweropen_syscall) + __(int $3) +_endsubp(poweropen_syscall) + +_spentry(eabi_ff_call) + __(int $3) +_endsubp(eabi_ff_call) + +_spentry(eabi_callback) + __(int $3) +_endsubp(eabi_callback) + + +/* Unused, and often not used on PPC either */ +_spentry(callbuiltin) + __(int $3) +_endsubp(callbuiltin) + +_spentry(callbuiltin0) + __(int $3) +_endsubp(callbuiltin0) + +_spentry(callbuiltin1) + __(int $3) +_endsubp(callbuiltin1) + +_spentry(callbuiltin2) + __(int $3) +_endsubp(callbuiltin2) + +_spentry(callbuiltin3) + __(int $3) +_endsubp(callbuiltin3) + +_spentry(restorefullcontext) + __(int $3) +_endsubp(restorefullcontext) + +_spentry(savecontextvsp) + __(int $3) +_endsubp(savecontextvsp) + +_spentry(savecontext0) + __(int $3) +_endsubp(savecontext0) + +_spentry(restorecontext) + __(int $3) +_endsubp(restorecontext) + +_spentry(stkconsyz) + __(int $3) +_endsubp(stkconsyz) + +_spentry(stkvcell0) + __(int $3) +_endsubp(stkvcell0) + +_spentry(stkvcellvsp) + __(int $3) +_endsubp(stkvcellvsp) + +_spentry(breakpoint) + __(int $3) +_endsubp(breakpoint) + +_spentry(unused_5) + __(int $3) +_endsubp(unused_5) + +_spentry(unused_6) + __(int $3) +_endsubp(unused_6) Index: /branches/ia32/lisp-kernel/x86-subprims32.s =================================================================== --- /branches/ia32/lisp-kernel/x86-subprims32.s (revision 8067) +++ /branches/ia32/lisp-kernel/x86-subprims32.s (revision 8068) @@ -1,4 +1,50 @@ include(lisp.s) - _beginfile + + .globl _SPmkcatch1v + .globl _SPnthrow1value + +/* This is called from a c-style context and calls a lisp function.*/ +/* This does the moral equivalent of*/ +/* (loop */ +/* (let* ((fn (%function_on_top_of_lisp_stack)))*/ +/* (if fn*/ +/* (catch %toplevel-catch%*/ +/* (funcall fn))*/ +/* (return nil))))*/ + + +_exportfn(toplevel_loop) + __(push %ebp) + __(movl %esp,%ebp) + /* Switch to the lisp stack */ + __(movl %esp,%rcontext:tcr.foreign_sp) + __(movl %rcontext:tcr.save_vsp,%esp) + __(push $0) + __(mov %esp,%ebp) + __(jmp local_label(test)) +local_label(loop): + __(ref_nrs_value(toplcatch,%arg_z)) + __(movl [$]local_label(back_from_catch),%ra0) + __(movl [$]local_label(test),%xfn) + __(push %ra0) + __(jmp _SPmkcatch1v) +__(tra(local_label(back_from_catch))) + __(movl %arg_y,%temp0) + __(pushl [$]local_label(back_from_funcall)) + __(set_nargs(0)) + __(jmp _SPfuncall) +__(tra(local_label(back_from_funcall))) + __(movl $fixnumone,%imm0) + __(movl [$]local_label(test),%ra0) + __(jmp _SPnthrow1value) +__(tra(local_label(test))) + __(movl 4(%ebp),%arg_y) + __(cmpl $nil_value,%arg_y) + __(jnz local_label(loop)) +local_label(back_to_c): + __(movl %rcontext:tcr.foreign_sp,%esp) + __(movl %esp,%ebp) + __(leave) + __(ret) /* This is called from C code when a thread (including the initial thread) */ @@ -43,2 +89,4 @@ __(ret) _endfn + +