Changeset 8070


Ignore:
Timestamp:
Jan 15, 2008, 2:52:34 AM (12 years ago)
Author:
rme
Message:

Numerous changes to get an IA-32 lisp kernel up and limping.

Location:
branches/ia32/lisp-kernel
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • branches/ia32/lisp-kernel/gc.h

    r7244 r8070  
    5050                                       (1<<fulltag_function)))
    5151#else
     52#define is_node_fulltag(f)  ((1<<(f))&((1<<fulltag_cons) | \
     53                                       (1<<fulltag_misc) | \
     54                                       (1<<fulltag_tra)))
    5255#endif
    5356#endif
  • branches/ia32/lisp-kernel/image.c

    r7017 r8070  
    285285#endif
    286286#endif
     287#ifdef X86
    287288#ifdef X8664
    288289        image_nil = (LispObj)(a->low) + (1024*4) + fulltag_nil;
     290#else
     291        image_nil = (LispObj)(a->low) + (1024*4) + fulltag_cons;
     292#endif
    289293#endif
    290294        set_nil(image_nil);
  • branches/ia32/lisp-kernel/lisptypes.h

    r7017 r8070  
    149149#ifdef X8632
    150150/* Assume rational <i386/ucontext.h> */
     151#define UC_MCONTEXT(UC) UC->uc_mcontext
    151152typedef mcontext_t MCONTEXT_T;
    152153typedef ucontext_t ExceptionInformation;
  • branches/ia32/lisp-kernel/pmcl-kernel.c

    r7244 r8070  
    16401640xGetSharedLibrary(char *path, int *resultType)
    16411641{
    1642 #if WORD_SIZE == 32
     1642#if defined(PPC) && (WORD_SIZE == 32)
    16431643  NSObjectFileImageReturnCode code;
    16441644  NSObjectFileImage              moduleImage;
  • branches/ia32/lisp-kernel/thread_manager.c

    r7286 r8070  
    563563{
    564564    uintptr_t addr = (uintptr_t)tcr;
    565     unsigned int size = sizeof(TCR);
     565    unsigned int size = sizeof(*tcr);
    566566    ldt_entry_t desc;
    567567    sel_t sel;
     
    587587        sel.rpl = USER_PRIV;
    588588        sel.ti = SEL_LDT;
    589         tcr->ldt_index = i;
     589        tcr->ldt_selector = sel;
    590590    }
    591591}
     
    613613  setup_tcr_extra_segment(tcr);
    614614#endif
    615 #else
     615#else /* no TLS */
    616616  TCR *tcr = allocate_tcr();
    617617#ifdef X8632
     
    620620#endif
    621621
    622 #ifdef X8664
     622#ifdef X86
    623623  tcr->linear = tcr;
    624624#endif
  • branches/ia32/lisp-kernel/x86-constants32.h

    r7243 r8070  
    1313#endif
    1414
     15/* Indicies of GPRs in the mcontext component of a ucontext */
     16#define Iimm0  REG_EAX
     17#define Ifn    REG_EBX
    1518#define Itemp0 REG_ECX
     19#define Itemp1 REG_ECX
    1620#define Iarg_y REG_EDI
    1721#define Iarg_z REG_ESI
    18 #define Ifn REG_EBX
    19 
    20 #define Isp REG_ESP
    21 #define Iip REG_EIP
     22#define Iesp   REG_ESP
     23#define Iebp   REG_EBP
     24#define Ieip   REG_EIP
     25
     26#define Isp Iesp
     27#define Iip Ieip
     28#define Iallocptr Itemp0
     29#define Ira0 Itemp0
     30#define Inargs Iimm0
     31#define Ixfn Itemp1
    2232
    2333#define nbits_in_word 32
     
    334344#include "lisp-errors.h"
    335345
     346#ifdef DARWIN
     347#include <architecture/i386/sel.h>
     348#endif
     349
    336350#define TCR_BIAS 0
    337351
     
    341355    u32_t node_regs_mask; /* bit set means correspnding reg contains node */
    342356    struct tcr *linear;
     357  /* this spill area must be 16-byte aligned */
     358    LispObj save0;              /* spill area for node registers */
     359    LispObj save1;
     360    LispObj save2;
     361    LispObj save3;
    343362    LispObj *save_ebp;          /* EBP when in foreign code */
    344363    u32_t lisp_mxcsr;
     
    354373    LispObj cs_limit;                   /* stack overflow limit */
    355374    natural bytes_allocated;
     375    natural bytes_consed_high;
    356376    natural log2_allocation_quantum;      /* for per-thread consing */
    357377    signed_natural interrupt_pending;     /* pending interrupt flag */
     
    383403    LispObj *next_tsp;
    384404    void *safe_ref_address;
    385     int ldt_index;
    386     int ldt_selector;
     405    sel_t ldt_selector;
    387406} TCR;
    388407
  • branches/ia32/lisp-kernel/x86-exceptions.c

    r7666 r8070  
    150150handle_gc_trap(ExceptionInformation *xp, TCR *tcr)
    151151{
     152#ifdef X8664
    152153  LispObj
    153154    selector = xpGPR(xp,Iimm0),
     
    246247    break;
    247248  }
     249#endif
    248250  return true;
    249251}
     
    269271{
    270272  natural nargs = (xpGPR(xp,Inargs)&0xffff)>> fixnumshift;
    271   signed_natural disp = nargs-3;
     273  signed_natural disp;
    272274  LispObj *vsp =  (LispObj *) xpGPR(xp,Isp), ra = *vsp++;
    273    
    274  
     275
     276#ifdef X8664
     277  disp = nargs - 3;
     278#endif
     279#ifdef X8632
     280  disp = nargs - 2;
     281#endif
     282
     283#ifdef X8664
    275284  if (disp > 0) {               /* implies that nargs > 3 */
    276285    vsp[disp] = xpGPR(xp,Irbp);
     
    295304    }
    296305  }
     306#endif
     307#ifdef X8632
     308  if (disp > 0) {               /* implies that nargs > 2 */
     309    vsp[disp] = xpGPR(xp,Iebp);
     310    vsp[disp+1] = ra;
     311    xpGPR(xp,Iebp) = (LispObj)(vsp+disp);
     312    xpGPR(xp,Isp) = (LispObj)vsp;
     313    push_on_lisp_stack(xp,xpGPR(xp,Iarg_y));
     314    push_on_lisp_stack(xp,xpGPR(xp,Iarg_z));
     315  } else {
     316    push_on_lisp_stack(xp,ra);
     317    push_on_lisp_stack(xp,xpGPR(xp,Iebp));
     318    xpGPR(xp,Iebp) = xpGPR(xp,Isp);
     319    if (nargs == 2) {
     320      push_on_lisp_stack(xp,xpGPR(xp,Iarg_y));
     321    }
     322    if (nargs >= 1) {
     323      push_on_lisp_stack(xp,xpGPR(xp,Iarg_z));
     324    }
     325  }
     326#endif
    297327}
    298328
     
    320350  f = xpGPR(xp,Ifn);
    321351  tra = *(LispObj*)(xpGPR(xp,Isp));
     352
     353#ifdef X8664
    322354  if (tag_of(tra) == tag_tra) {
    323355    if ((*((unsigned short *)tra) == RECOVER_FN_FROM_RIP_WORD0) &&
     
    332364    tra = 0;
    333365  }
     366#endif
     367#ifdef X8632
     368  if (fulltag_of(tra) == fulltag_tra) {
     369    if (*((unsigned char *)(tra)) == RECOVER_FN_OPCODE) {
     370      tra_f = (LispObj)(*((natural *)(tra + 1)));
     371    }
     372    if (tra_f && header_subtag(header_of(tra_f)) != subtag_function) {
     373      tra_f = 0;
     374    }
     375  } else {
     376    tra = 0;
     377  }
     378#endif
    334379
    335380  abs_pc = (LispObj)xpPC(xp);
    336381
     382#ifdef X8664
    337383  if (fulltag_of(f) == fulltag_function) {
     384#else
     385  if (header_subtag(header_of(f)) == subtag_function) {
     386#endif
    338387    nominal_function = f;
    339388  } else {
     
    373422  push_on_lisp_stack(xp,nominal_function);
    374423  push_on_lisp_stack(xp,0);
     424#ifdef X8664
    375425  push_on_lisp_stack(xp,xpGPR(xp,Irbp));
    376426  xpGPR(xp,Irbp) = xpGPR(xp,Isp);
     427#else
     428  push_on_lisp_stack(xp,xpGPR(xp,Iebp));
     429  xpGPR(xp,Iebp) = xpGPR(xp,Isp);
     430#endif
    377431  return xpGPR(xp,Isp);
    378432}
     
    392446  allocptr_tag = fulltag_of(cur_allocptr);
    393447  if (allocptr_tag == fulltag_misc) {
     448#ifdef X8664
    394449    disp = xpGPR(xp,Iimm1);
     450#else
     451    disp = xpGPR(xp,Iimm0);
     452#endif
    395453  } else {
    396454    disp = dnode_size-fulltag_cons;
     
    434492  /* Put the active stack pointers where .SPcallback expects them */
    435493  tcr->save_vsp = (LispObj *) xpGPR(xp, Isp);
     494#ifdef X8664
    436495  tcr->save_rbp = (LispObj *) xpGPR(xp, Irbp);
    437 
     496#else
     497  tcr->save_ebp = (LispObj *) xpGPR(xp, Iebp);
     498#endif
    438499
    439500  /* Call back.  The caller of this function may have modified stack/frame
     
    451512callback_for_interrupt(TCR *tcr, ExceptionInformation *xp)
    452513{
    453   LispObj save_rbp = xpGPR(xp,Irbp),
    454     *save_vsp = (LispObj *)xpGPR(xp,Isp),
     514  LispObj *save_vsp = (LispObj *)xpGPR(xp,Isp),
    455515    word_beyond_vsp = save_vsp[-1],
    456516    xcf = create_exception_callback_frame(xp);
    457517  int save_errno = errno;
    458  
     518#ifdef X8664
     519  LispObj save_rbp = xpGPR(xp,Irbp);
     520#else
     521  LispObj save_ebp = xpGPR(xp,Iebp);
     522#endif
     523
    459524  callback_to_lisp(tcr, nrs_CMAIN.vcell,xp, xcf, 0, 0, 0, 0);
     525#ifdef X8664
    460526  xpGPR(xp,Irbp) = save_rbp;
     527#else
     528  xpGPR(xp,Iebp) = save_ebp;
     529#endif
    461530  xpGPR(xp,Isp) = (LispObj)save_vsp;
    462531  save_vsp[-1] = word_beyond_vsp;
     
    470539  unsigned char op0 = program_counter[0], op1 = program_counter[1];
    471540  LispObj rpc = (LispObj) program_counter, errdisp = nrs_ERRDISP.vcell,
    472     save_rbp = xpGPR(xp,Irbp), save_vsp = xpGPR(xp,Isp), xcf;
     541    save_vsp = xpGPR(xp,Isp), xcf;
     542#ifdef X8664
     543  LispObj save_rbp = xpGPR(xp,Irbp);
     544#else
     545  LispObj save_ebp = xpGPR(xp,Iebp);
     546#endif
     547
    473548  int skip;
    474549
     
    481556    xcf = create_exception_callback_frame(xp);
    482557    skip = callback_to_lisp(tcr, errdisp, xp, xcf, 0, 0, 0, 0);
     558#ifdef X8664
    483559    xpGPR(xp,Irbp) = save_rbp;
     560#else
     561    xpGPR(xp,Iebp) = save_ebp;
     562#endif
    484563    xpGPR(xp,Isp) = save_vsp;
    485564    if ((op0 == 0xcd) && (op1 == 0xc7)) {
     
    556635  lisp_protection_kind which = prot_area->why;
    557636  Boolean on_TSP = (which == kTSPsoftguard);
    558   LispObj save_rbp = xpGPR(xp,Irbp),
    559     save_vsp = xpGPR(xp,Isp),
     637#ifdef X8664
     638  LispObj save_rbp = xpGPR(xp,Irbp);
     639#else
     640  LispObj save_ebp = xpGPR(xp,Iebp);
     641#endif
     642  LispObj save_vsp = xpGPR(xp,Isp),
    560643    xcf,
    561644    cmain = nrs_CMAIN.vcell;
     
    576659    xcf = create_exception_callback_frame(xp);
    577660    skip = callback_to_lisp(tcr, nrs_CMAIN.vcell, xp, xcf, SIGSEGV, on_TSP, 0, 0);
     661#ifdef X8664
    578662    xpGPR(xp,Irbp) = save_rbp;
     663#else
     664    xpGPR(xp,Iebp) = save_ebp;
     665#endif
    579666    xpGPR(xp,Isp) = save_vsp;
    580667    xpPC(xp) += skip;
     
    588675{
    589676#ifdef DARWIN
     677#ifdef X8664
    590678  return (UC_MCONTEXT(xp)->__es.__err & 0x2) != 0;
     679#else
     680  return (xp->uc_mcontext->__es.__err & 0x2) != 0;
     681#endif
    591682#endif
    592683#ifdef LINUX
     
    638729  pc program_counter = (pc)xpPC(xp);
    639730  LispObj rpc = (LispObj) program_counter, xcf, cmain = nrs_CMAIN.vcell,
    640 
    641     save_rbp = xpGPR(xp,Irbp), save_vsp = xpGPR(xp,Isp);
     731    save_vsp = xpGPR(xp,Isp);
     732#ifdef X8664
     733  LispObj save_rbp = xpGPR(xp,Irbp);
     734#else
     735  LispObj save_ebp = xpGPR(xp,Iebp);
     736#endif
    642737
    643738  if ((fulltag_of(cmain) == fulltag_misc) &&
     
    646741    skip = callback_to_lisp(tcr, cmain, xp, xcf, SIGFPE, code, 0, 0);
    647742    xpPC(xp) += skip;
     743#ifdef X8664
    648744    xpGPR(xp,Irbp) = save_rbp;
     745#else
     746    xpGPR(xp,Iebp) = save_ebp;
     747#endif
    649748    xpGPR(xp,Isp) = save_vsp;
    650749    return true;
     
    16571756pc_luser_xp(ExceptionInformation *xp, TCR *tcr, signed_natural *interrupt_displacement)
    16581757{
     1758#ifdef X8664
    16591759  pc program_counter = (pc)xpPC(xp);
    16601760  int allocptr_tag = fulltag_of((LispObj)(tcr->save_allocptr));
     
    18151915    return;
    18161916  }
     1917#endif
    18171918}
    18181919
     
    20932194  MCONTEXT_T mc = UC_MCONTEXT(pseudosigcontext);
    20942195#else
    2095   struct mcontext * mc = UC_MCONTEXT(pseudosigcontext);
     2196  mcontext_t mc = UC_MCONTEXT(pseudosigcontext);
    20962197#endif
    20972198
     
    21602261                            x86_thread_state64_t *ts
    21612262#else
    2162                             x86_thread_state_t *ts
     2263                            x86_thread_state32_t *ts
    21632264#endif
    21642265                            )
     
    21712272  MCONTEXT_T mc;
    21722273#else
    2173   struct mcontext *mc;
     2274  mcontext_t mc;
    21742275#endif
    21752276  natural stackp, backlink;
    21762277
    2177  
     2278#ifdef X8664 
    21782279  stackp = (LispObj) find_foreign_rsp(ts->__rsp,tcr->cs_area,tcr);
     2280#else
     2281  stackp = (LispObj) ts->__esp;
     2282#endif
     2283
    21792284  stackp = TRUNC_DOWN(stackp, C_REDZONE_LEN, C_STK_ALIGN);
    21802285  stackp = TRUNC_DOWN(stackp, sizeof(siginfo_t), C_STK_ALIGN);
     
    21892294  mc = (MCONTEXT_T) ptr_from_lispobj(stackp);
    21902295#else
    2191   mc = (struct mcontext *) ptr_from_lispobj(stackp);
     2296  mc = (mcontext_t) ptr_from_lispobj(stackp);
    21922297#endif
    21932298 
     
    22492354                   x86_thread_state64_t *ts
    22502355#else
    2251                    x86_thread_state_t *ts
     2356                   x86_thread_state32_t *ts
    22522357#endif
    22532358                   )
     
    22562361  x86_thread_state64_t new_ts;
    22572362#else
    2258   x86_thread_state_t new_ts;
     2363  x86_thread_state32_t new_ts;
    22592364#endif
    22602365  ExceptionInformation *pseudosigcontext;
     
    22892394  */
    22902395
     2396#ifdef X8664
    22912397  new_ts.__rip = (natural) handler_address;
    22922398  stackpp = (natural *)stackp;
     
    23002406  new_ts.__rsp = stackp;
    23012407  new_ts.__rflags = ts->__rflags;
    2302 
     2408#else
     2409  new_ts.__eip = (natural)handler_address;
     2410  stackpp = (natural *)stackp;
     2411  *--stackpp = (natural)pseudo_sigreturn;
     2412  stackp = (natural)stackpp;
     2413  /* xxx and other stuff */
     2414  new_ts.__esp = stackp;
     2415  new_ts.__eflags = ts->__eflags;
     2416#endif
    23032417
    23042418#ifdef X8664
     
    23522466#define ts_pc(t) t.__rip
    23532467#else
    2354 #define ts_pc(t) t.eip
     2468#define ts_pc(t) t.__eip
    23552469#endif
    23562470
     
    23762490  x86_thread_state64_t ts;
    23772491#else
    2378   x86_thread_state_t ts;
     2492  x86_thread_state32_t ts;
    23792493#endif
    23802494  mach_msg_type_number_t thread_state_count;
     
    24042518  MACH_CHECK_ERROR("getting thread state",call_kret);
    24052519#else
    2406     thread_state_count = x86_THREAD_STATE_COUNT;
    2407     thread_get_state(thread,
    2408                      x86_THREAD_STATE,
    2409                      (thread_state_t)&ts,
    2410                      &thread_state_count);
     2520    thread_state_count = x86_THREAD_STATE32_COUNT;
     2521    call_kret = thread_get_state(thread,
     2522                                 x86_THREAD_STATE32,
     2523                                 (thread_state_t)&ts,
     2524                                 &thread_state_count);
     2525    MACH_CHECK_ERROR("getting thread state",call_kret);
    24112526#endif
    24122527    if (tcr->flags & (1<<TCR_FLAG_BIT_PENDING_EXCEPTION)) {
     
    27632878                     &thread_state_count);
    27642879#else
    2765     x86_thread_state_t ts;
     2880    x86_thread_state32_t ts;
    27662881    thread_state_count = x86_THREAD_STATE_COUNT;
    27672882    thread_get_state(mach_thread,
  • branches/ia32/lisp-kernel/x86-exceptions.h

    r7287 r8070  
    3939#define xpMMXreg(x,n)  (xpFPRvector(x)[n])
    4040#else /* X8632 */
    41 #define xpGPRvector(x) ((natural *)(&((x)->uc_mcontext->ss)))
     41#define xpGPRvector(x) ((natural *)(&((x)->uc_mcontext->__ss.__eax)))
    4242#define xpGPR(x,gprno) (xpGPRvector(x)[gprno])
    4343#define set_xpGPR(x,gpr,new) xpGPR((x),(gpr)) = (natural)(new)
    4444#define xpPC(x) (xpGPR(x,Iip))
    45 #define xpFPRvector(x) ((natural *)(&((x)->uc_mcontext->fs.fpu_xmm0)))
     45#define xpFPRvector(x) ((natural *)(&((x)->uc_mcontext->__fs.__fpu_xmm0)))
     46/* are you ready for this? */
     47#define xpMMXreg(x,n) *((natural *)&((&((x)->uc_mcontext->__fs.__fpu_stmm0))[n]))
    4648#endif
    4749#include <mach/mach.h>
  • branches/ia32/lisp-kernel/x86-gc.c

    r7244 r8070  
    6767  case fulltag_even_fixnum:
    6868  case fulltag_odd_fixnum:
     69#ifdef X8632
     70  case fulltag_imm:
     71#endif
     72#ifdef X8664
    6973  case fulltag_imm_0:
    7074  case fulltag_imm_1:
     75#endif
    7176    return;
    7277
     78#ifdef X8664
    7379  case fulltag_nil:
    7480    if (n != lisp_nil) {
     
    7682    }
    7783    return;
    78 
    79 
     84#endif
     85
     86#ifdef X8632
     87  case fulltag_nodeheader:
     88  case fulltag_immheader:
     89#endif
     90#ifdef X8664
    8091  case fulltag_nodeheader_0:
    8192  case fulltag_nodeheader_1:
     
    8394  case fulltag_immheader_1:
    8495  case fulltag_immheader_2:
     96#endif
    8597    Bug(NULL, "Header not expected : 0x%lx", n);
    8698    return;
    8799
     100#ifdef X8632
     101  case fulltag_tra:
     102#endif
     103#ifdef X8664
    88104  case fulltag_tra_0:
    89105  case fulltag_tra_1:
     106#endif
    90107    a = heap_area_containing((BytePtr)ptr_from_lispobj(n));
    91108    if (a == NULL) {
     
    100117       check the function it (should) identify.
    101118    */
     119#ifdef X8632
     120    {
     121      LispObj fun;
     122
     123      if (*((unsigned char *)n) == RECOVER_FN_OPCODE) {
     124        fun = (LispObj)(*((natural *)(n + 1)));
     125      }
     126      if (fun == 0 ||
     127         (header_subtag(header_of(fun)) != subtag_function) ||
     128         (heap_area_containing((BytePtr)ptr_from_lispobj(fun)) != a)) {
     129        Bug(NULL, "TRA at 0x%x has bad function address 0x%x\n", n, fun);
     130      }
     131      n = fun;
     132    }
     133#endif
     134#ifdef X8664
    102135    {
    103136      int disp = 0;
     
    115148      }
    116149    }
     150#endif
    117151    /* Otherwise, fall through and check the header on the function
    118152       that the tra references */
     
    120154  case fulltag_misc:
    121155  case fulltag_cons:
     156#ifdef X8664
    122157  case fulltag_symbol:
    123158  case fulltag_function:
     159#endif
    124160    a = heap_area_containing((BytePtr)ptr_from_lispobj(n));
    125161   
     
    292328  }
    293329
     330#ifdef X8632
     331  if (tag_n == fulltag_tra) {
     332    if (*((unsigned char *)n) == RECOVER_FN_OPCODE)
     333      n = (LispObj)(*((natural *)(n + 1)));
     334    else
     335      return;
     336  }
     337#endif
     338#ifdef X8664
    294339  if (tag_of(n) == tag_tra) {
    295340    if ((*((unsigned short *)n) == RECOVER_FN_FROM_RIP_WORD0) &&
     
    303348    }
    304349  }
     350#endif
    305351
    306352
     
    334380    tag_n = fulltag_of(header);
    335381
    336 
     382#ifdef X8664
    337383    if ((nodeheader_tag_p(tag_n)) ||
    338384        (tag_n == ivector_class_64_bit)) {
     
    350396      }
    351397    }
     398#endif
     399#ifdef X8632
     400    if ((tag_n == fulltag_nodeheader) ||
     401        (subtag <= max_32_bit_ivector_subtag)) {
     402      total_size_in_bytes = 4 + (element_count<<2);
     403    } else if (subtag <= max_8_bit_ivector_subtag) {
     404      total_size_in_bytes = 4 + element_count;
     405    } else if (subtag <= max_16_bit_ivector_subtag) {
     406      total_size_in_bytes = 4 + (element_count<<1);
     407    } else if (subtag == subtag_double_float_vector) {
     408      total_size_in_bytes = 8 + (element_count<<3);
     409    } else {
     410      total_size_in_bytes = 4 + ((element_count+7)>>3);
     411    }
     412#endif
     413
    352414
    353415    suffix_dnodes = ((total_size_in_bytes+(dnode_size-1))>>dnode_shift) -1;
     
    447509GCstack_limit = 0;
    448510
     511#ifdef X8632
     512void rmark(LispObj n)
     513{
     514}
     515#else
    449516
    450517/*
     
    464531  }
    465532
     533#ifdef X8632
     534  if (tag_n == fulltag_tra) {
     535    if (*((unsigned char *)n) == RECOVER_FN_OPCODE)
     536      n = (LispObj)(*((natural *)(n + 1)));
     537    else
     538      return;
     539  }
     540#endif
     541#ifdef X8664
    466542  if (tag_of(n) == tag_tra) {
    467543    if ((*((unsigned short *)n) == RECOVER_FN_FROM_RIP_WORD0) &&
     
    474550    }
    475551  }
     552#endif
    476553
    477554  dnode = gc_area_dnode(n);
     
    501578      tag_n = fulltag_of(header);
    502579
     580#ifdef X8664
    503581      if ((nodeheader_tag_p(tag_n)) ||
    504582          (tag_n == ivector_class_64_bit)) {
     
    516594        }
    517595      }
     596#endif
     597#ifdef X8632
     598      if ((tag_n == fulltag_nodeheader) ||
     599          (subtag <= max_32_bit_ivector_subtag)) {
     600        total_size_in_bytes = 4 + (element_count<<2);
     601      } else if (subtag <= max_8_bit_ivector_subtag) {
     602        total_size_in_bytes = 4 + element_count;
     603      } else if (subtag <= max_16_bit_ivector_subtag) {
     604        total_size_in_bytes = 4 + (element_count<<1);
     605      } else if (subtag == subtag_double_float_vector) {
     606        total_size_in_bytes = 8 + (element_count<<3);
     607      } else {
     608        total_size_in_bytes = 4 + ((element_count+7)>>3);
     609      }
     610#endif
     611
    518612      suffix_dnodes = ((total_size_in_bytes+(dnode_size-1))>>dnode_shift)-1;
    519613
     
    839933  }
    840934}
     935#endif
    841936
    842937LispObj *
     
    849944
    850945
    851 
     946#ifdef X8664
    852947  switch (fulltag_of(header)) {
    853948  case ivector_class_64_bit:
     
    868963  }
    869964  return ptr_from_lispobj(start+(~15 & (nbytes + 8 + 15)));
    870 
     965#else
     966  if (subtag <= max_32_bit_ivector_subtag) {
     967    nbytes = element_count << 2;
     968  } else if (subtag <= max_8_bit_ivector_subtag) {
     969    nbytes = element_count;
     970  } else if (subtag <= max_16_bit_ivector_subtag) {
     971    nbytes = element_count << 1;
     972  } else if (subtag == subtag_double_float_vector) {
     973    nbytes = 4 + (element_count << 3);
     974  } else {
     975    nbytes = (element_count+7) >> 3;
     976  }
     977  return ptr_from_lispobj(start+(~7 & (nbytes + 4 + 7)));
     978#endif
    871979}
    872980
     
    14661574
    14671575/* Mark the lisp objects in an exception frame */
     1576#ifdef X8664
    14681577void
    14691578mark_xp(ExceptionInformation *xp)
     
    15041613  }
    15051614}
     1615#else
     1616void
     1617mark_xp(ExceptionInformation *xp, unsigned char node_regs_mask)
     1618{
     1619  natural *regs = (natural *) xpGPRvector(xp), dnode;
     1620  LispObj eip;
     1621  int i;
     1622
     1623  for (i = 0; i < 8; i ++) {
     1624    if (node_regs_mask & (1<<i)) {
     1625      mark_root(regs[i]);
     1626    }
     1627  }
     1628  /* If the EIP isn't pointing into a marked function, we're probably
     1629     in trouble.  We can -maybe- recover from that if it's tagged as a
     1630     TRA. */
     1631  eip = regs[Ieip];
     1632  dnode = gc_area_dnode(eip);
     1633  if ((dnode < GCndnodes_in_area) &&
     1634      (! ref_bit(GCmarkbits,dnode))) {
     1635    if (fulltag_of(eip) == fulltag_tra) {
     1636      mark_root(eip);
     1637    } else if ((fulltag_of(eip) == fulltag_misc) &&
     1638               (header_subtag(header_of(eip)) == subtag_function) &&
     1639               (*((unsigned char *)(eip)) == RECOVER_FN_OPCODE) &&
     1640               ((LispObj)(*((natural *)(eip + 1))) == eip)) {
     1641      mark_root(eip);
     1642    } else {
     1643      Bug(NULL, "Can't find function for eip 0x%8x", eip);
     1644    }
     1645  }
     1646}
     1647#endif
    15061648
    15071649void
     
    15371679  xp = tcr->gc_context;
    15381680  if (xp) {
     1681#ifdef X8664
    15391682    mark_xp(xp);
     1683#else
     1684    mark_xp(xp, tcr->node_regs_mask);
     1685#endif
    15401686  }
    15411687 
     
    15431689       xframes;
    15441690       xframes = xframes->prev) {
     1691#ifdef X8664
    15451692      mark_xp(xframes->curr);
     1693#else
     1694      mark_xp(xframes->curr, tcr->node_regs_mask);
     1695#endif
    15461696  }
    15471697}
     
    20642214  natural *regs = (natural *) xpGPRvector(xp);
    20652215
     2216#ifdef X8664
    20662217  update_noderef(&(regs[Iarg_z]));
    20672218  update_noderef(&(regs[Iarg_y]));
     
    20762227  update_noderef(&(regs[Itemp2]));
    20772228  update_locref(&(regs[Iip]));
     2229#endif
    20782230}
    20792231
     
    22852437          tag = header_subtag(node);
    22862438
    2287 
     2439#ifdef X8664
    22882440          switch(fulltag_of(tag)) {
    22892441          case ivector_class_64_bit:
     
    23022454            }
    23032455          }
     2456#endif
     2457#ifdef X8632
     2458          if (tag <= max_32_bit_ivector_subtag) {
     2459            if (tag == subtag_code_vector) {
     2460              GCrelocated_code_vector = true;
     2461            }
     2462            imm_dnodes = (((elements+1)+1)>>1);
     2463          } else if (tag <= max_8_bit_ivector_subtag) {
     2464            imm_dnodes = (((elements+4)+7)>>3);
     2465          } else if (tag <= max_16_bit_ivector_subtag) {
     2466            imm_dnodes = (((elements+2)+3)>>2);
     2467          } else if (tag == subtag_bit_vector) {
     2468            imm_dnodes = (((elements+32)+63)>>6);
     2469          } else {
     2470            imm_dnodes = elements+1;
     2471          }
     2472#endif
     2473
    23042474          dnode += imm_dnodes;
    23052475          while (--imm_dnodes) {
     
    25442714      for (i = 0; i < n; i++) {
    25452715        sym = *raw++;
     2716#ifdef X8664
    25462717        if (fulltag_of(sym) == fulltag_symbol) {
     2718#endif
     2719#ifdef X8632
     2720        if (fulltag_of(sym) == fulltag_misc) {
     2721#endif
    25472722          lispsymbol *rawsym = (lispsymbol *)ptr_from_lispobj(untag(sym));
    25482723          natural dnode = gc_area_dnode(sym);
     
    25802755      for (i = 0; i < n; i++, raw++) {
    25812756        sym = *raw;
     2757#ifdef X8664
    25822758        if (fulltag_of(sym) == fulltag_symbol) {
     2759#endif
     2760#ifdef X8632
     2761        if (fulltag_of(sym) == fulltag_misc) {
     2762#endif
    25832763          lispsymbol *rawsym = (lispsymbol *)ptr_from_lispobj(untag(sym));
    25842764          natural dnode = gc_area_dnode(sym);
     
    27522932        subtag = header_subtag(header);
    27532933
     2934#ifdef X8664
    27542935        switch(fulltag_of(header)) {
    27552936        case ivector_class_64_bit:
     
    27692950          }
    27702951        }
     2952#endif
     2953#ifdef X8632
     2954          if (subtag <= max_32_bit_ivector_subtag) {
     2955            bytes = 4 + (elements<<2);
     2956          } else if (subtag <= max_8_bit_ivector_subtag) {
     2957            bytes = 4 + elements;
     2958          } else if (subtag <= max_16_bit_ivector_subtag) {
     2959            bytes = 4 + (elements<<1);
     2960          } else if (subtag == subtag_double_float_vector) {
     2961            bytes = 8 + (elements<<3);
     2962          } else {
     2963            bytes = 4 + ((elements+7)>>3);
     2964          }
     2965#endif
     2966
    27712967        bytes = (bytes+dnode_size-1) & ~(dnode_size-1);
    27722968        total += bytes;
     
    27912987purify_displaced_object(LispObj obj, area *dest, natural disp)
    27922988{
     2989#ifdef X8664
    27932990  BytePtr
    27942991    free = dest->active,
     
    28393036  }
    28403037  return new;
     3038#endif
    28413039}
    28423040
     
    28663064  natural elements, i, nbytes = 0;
    28673065
     3066#ifdef X8664
    28683067  while (fulltag_of(pkg_list) == fulltag_cons) {
    28693068    c = (cons *) ptr_from_lispobj(untag(pkg_list));
     
    29013100    }
    29023101  }
     3102#endif
    29033103  return nbytes;
    29043104}
     
    29113111  Boolean changed = false;
    29123112
     3113#ifdef X8664
    29133114  if ((tag == fulltag_misc) &&
    29143115      (((BytePtr)ptr_from_lispobj(obj)) > low) &&
     
    29313132    }
    29323133  }
     3134#endif
    29333135  return changed;
    29343136}
     
    29463148purify_range(LispObj *start, LispObj *end, BytePtr low, BytePtr high, area *to, int what)
    29473149{
     3150#ifdef X8664
    29483151  LispObj header;
    29493152  unsigned tag;
     
    30103213    }
    30113214  }
     3215#endif
    30123216}
    30133217       
     
    31513355  BytePtr new_pure_start;
    31523356
    3153 
     3357#ifdef X8664
    31543358
    31553359  max_pure_size = interned_pname_bytes_in_range((LispObj *)(a->low + (static_dnodes_for_area(a) << dnode_shift)),
     
    32313435    return 0;
    32323436  }
     3437#endif
    32333438  return -1;
    32343439}
     
    32903495impurify_range(LispObj *start, LispObj *end, LispObj low, LispObj high, int delta)
    32913496{
     3497#ifdef X8664
     3498
    32923499  LispObj header;
    32933500  unsigned tag;
     
    33543561    }
    33553562  }
     3563#endif
    33563564}
    33573565
     
    35423750  natural *regs = (natural *) xpGPRvector(xp);
    35433751
     3752#ifdef X8664
    35443753  adjust_noderef((LispObj *) (&(regs[Iarg_z])),base,limit,delta);
    35453754  adjust_noderef((LispObj *) (&(regs[Iarg_y])),base,limit,delta);
     
    35543763  adjust_noderef((LispObj *) (&(regs[Itemp2])),base,limit,delta);
    35553764  adjust_locref((LispObj *) (&(xpPC(xp))),base,limit,delta);
     3765#endif
    35563766}
    35573767
     
    35633773  natural *regs = (natural *) xpGPRvector(xp);
    35643774
     3775#ifdef X8664
    35653776  nuke_noderef((LispObj *) (&(regs[Iarg_z])),base,limit);
    35663777  nuke_noderef((LispObj *) (&(regs[Iarg_y])),base,limit);
     
    35743785  nuke_noderef((LispObj *) (&(regs[Itemp1])),base,limit);
    35753786  nuke_noderef((LispObj *) (&(regs[Itemp2])),base,limit);
    3576 
     3787#endif
    35773788}
    35783789
  • branches/ia32/lisp-kernel/x86_print.c

    r6522 r8070  
    317317sprint_tra(LispObj o, int depth)
    318318{
     319#ifdef X8664
    319320  signed sdisp;
    320321  unsigned disp;
     
    337338    sprint_unsigned_hex(o);
    338339  }
     340#endif
    339341}
    340342               
     
    512514      }
    513515      break;
    514    
     516
     517#ifdef X8664
    515518    case fulltag_nil:
     519#endif
    516520    case fulltag_cons:
    517521      sprint_list(o, depth);
     
    522526      break;
    523527
     528#ifdef X8664
    524529    case fulltag_symbol:
    525530      sprint_symbol(o);
     
    534539      sprint_tra(o,depth);
    535540      break;
     541#endif
    536542    }
    537543  }
  • branches/ia32/lisp-kernel/xlbt.c

    r6910 r8070  
    2323}
    2424
    25 
    2625void
    2726print_lisp_frame(lisp_frame *frame)
     
    3029  int delta = 0;
    3130
     31  if (pc == lisp_global(RET1VALN)) {
     32    pc = frame->xtra;
     33  }
     34#ifdef X8632
     35  if (fulltag_of(pc) == fulltag_tra) {
     36    if (*((unsigned char *)pc) == RECOVER_FN_OPCODE) {
     37      natural n = *((natural *)(pc + 1));
     38      fun = (LispObj)n;
     39    }
     40    if (fun && header_subtag(header_of(fun)) == subtag_function) {
     41      delta = pc - fun;
     42      Dprintf("(#x%08X) #x%08X : %s + %d", frame, pc, print_lisp_object(fun), delta);
     43      return;
     44    }
     45  }
     46  if (pc == 0) {
     47    fun = ((xcf *)frame)->nominal_function;
     48    Dprintf("(#x%08X) #x%08X : %s + ??", frame, pc, print_lisp_object(fun));
     49    return;
     50  }
     51#else
    3252  if (pc == lisp_global(RET1VALN)) {
    3353    pc = frame->xtra;
     
    5070    return;
    5171  }
     72#endif
    5273}
     74
    5375
    5476Boolean
     
    6587    }
    6688
     89#ifdef X8632
     90    if (fulltag_of(ra) == fulltag_tra) {
     91#else
    6792    if (tag_of(ra) == tag_tra) {
     93#endif
    6894#if 0
    6995      if ((*((unsigned short *)ra) == RECOVER_FN_FROM_RIP_WORD0) &&
     
    155181plbt(ExceptionInformation *xp)
    156182{
     183#ifdef X8632
     184  plbt_sp(xpGPR(xp,Iebp));
     185#else
    157186  plbt_sp(xpGPR(xp,Irbp));
     187#endif
    158188}
Note: See TracChangeset for help on using the changeset viewer.