Changeset 9701


Ignore:
Timestamp:
Jun 9, 2008, 1:05:03 AM (11 years ago)
Author:
gb
Message:

Propagate changes from trunk (except for some win64 changes); this mostly
means that subprims are consistent about using 32-bit operations on nargs
and that certain things (suspend/resume/interrupt) are serialized (implemented
via exceptions.)

Try to avoid some cases where we might use pthread_kill() on 0 (race
conditions involving thread death.)

Location:
branches/working-0711-perf/ccl/lisp-kernel
Files:
28 edited

Legend:

Unmodified
Added
Removed
  • branches/working-0711-perf/ccl/lisp-kernel/Threads.h

    r7828 r9701  
    182182#define SIG_RESUME_THREAD (SIG_SUSPEND_THREAD+1)
    183183#else
    184 #define SIG_SUSPEND_THREAD SIGUSR1
    185 #define SIG_RESUME_THREAD SIGUSR2
     184#define SIG_SUSPEND_THREAD SIGUSR2
    186185#endif
    187186
  • branches/working-0711-perf/ccl/lisp-kernel/errors.s

    r7624 r9701  
    2525error_excised_function_call = 6
    2626error_too_many_values = 7
    27 error_propagate_suspend = 10   
     27error_propagate_suspend = 10
     28error_interrupt = 11
     29error_suspend = 12
     30error_suspend_all = 13
     31error_resume = 14
     32error_resume_all = 15                                   
    2833error_cant_call = 17
    2934       
  • branches/working-0711-perf/ccl/lisp-kernel/gc-common.c

    r7626 r9701  
    2424#include <stdlib.h>
    2525#include <string.h>
     26
     27#ifndef WINDOWS
    2628#include <sys/time.h>
    27 
     29#endif
     30
     31#ifndef timeradd
     32# define timeradd(a, b, result)                                               \
     33  do {                                                                        \
     34    (result)->tv_sec = (a)->tv_sec + (b)->tv_sec;                             \
     35    (result)->tv_usec = (a)->tv_usec + (b)->tv_usec;                          \
     36    if ((result)->tv_usec >= 1000000)                                         \
     37      {                                                                       \
     38        ++(result)->tv_sec;                                                   \
     39        (result)->tv_usec -= 1000000;                                         \
     40      }                                                                       \
     41  } while (0)
     42#endif
     43#ifndef timersub
     44# define timersub(a, b, result)                                               \
     45  do {                                                                        \
     46    (result)->tv_sec = (a)->tv_sec - (b)->tv_sec;                             \
     47    (result)->tv_usec = (a)->tv_usec - (b)->tv_usec;                          \
     48    if ((result)->tv_usec < 0) {                                              \
     49      --(result)->tv_sec;                                                     \
     50      (result)->tv_usec += 1000000;                                           \
     51    }                                                                         \
     52  } while (0)
     53#endif
     54
     55void
     56comma_output_decimal(char *buf, int len, natural n)
     57{
     58  int nout = 0;
     59
     60  buf[--len] = 0;
     61  do {
     62    buf[--len] = n%10+'0';
     63    n = n/10;
     64    if (n == 0) {
     65      while (len) {
     66        buf[--len] = ' ';
     67      }
     68      return;
     69    }
     70    if (len == 0) return;
     71    nout ++;
     72    if (nout == 3) {
     73      buf[--len] = ',';
     74      nout = 0;
     75    }
     76  } while (len >= 0);
     77}
    2878
    2979
     
    4292natural GCndnodes_in_area = 0, GCndynamic_dnodes_in_area = 0;
    4393LispObj GCweakvll = (LispObj)NULL;
     94LispObj GCdwsweakvll = (LispObj)NULL;
    4495LispObj GCephemeral_low = 0;
    4596natural GCn_ephemeral_dnodes = 0;
     
    163214    dnode,
    164215    npairs = (header_element_count(hashp->header) -
    165               ((sizeof(hash_table_vector_header)/sizeof(LispObj)) -1)) >> 1;
     216              (hash_table_vector_header_count -1)) >> 1;
    166217  LispObj *pairp = (LispObj*) (hashp+1), weakelement;
    167218  Boolean
     
    188239    pairp += 2;
    189240  }
    190 }   
    191    
     241}
     242
     243void
     244traditional_dws_mark_htabv(LispObj htabv)
     245{
     246  /* Do nothing, just add htabv to GCweakvll */
     247  LispObj *base = (LispObj *) ptr_from_lispobj(untag(htabv));
     248 
     249  deref(base,1) = GCweakvll;
     250  GCweakvll = htabv;
     251}
     252
     253void
     254ncircle_dws_mark_htabv(LispObj htabv)
     255{
     256  /* Do nothing, just add htabv to GCdwsweakvll */
     257  LispObj *base = (LispObj *) ptr_from_lispobj(untag(htabv));
     258 
     259  deref(base,1) = GCdwsweakvll;
     260  GCdwsweakvll = htabv;
     261}
     262
     263void
     264traditional_mark_weak_htabv(LispObj htabv)
     265{
     266  int i, skip = hash_table_vector_header_count;;
     267
     268  for (i = 2; i <= skip; i++) {
     269    rmark(deref(htabv,i));
     270  }
     271
     272  deref(htabv,1) = GCweakvll;
     273  GCweakvll = htabv;
     274}
     275
     276void
     277ncircle_mark_weak_htabv(LispObj htabv)
     278{
     279  int i, skip = hash_table_vector_header_count;
     280  hash_table_vector_header *hashp = (hash_table_vector_header *)(untag(htabv));
     281  natural
     282    dnode,
     283    npairs = (header_element_count(hashp->header) -
     284              (hash_table_vector_header_count - 1)) >> 1;
     285  LispObj *pairp = (LispObj*) (hashp+1), weakelement;
     286  Boolean
     287    weak_on_value = ((hashp->flags & nhash_weak_value_mask) != 0);
     288  bitvector markbits = GCmarkbits;
     289  int tag;
     290
     291  for (i = 2; i <= skip; i++) {
     292    rmark(deref(htabv,i));
     293  }
     294 
     295  if (!weak_on_value) {
     296    pairp++;
     297  }
     298  /* unconditionally mark the non-weak element of each pair */
     299  while (npairs--) {
     300    rmark(*pairp);
     301    pairp += 2;
     302  }
     303
     304  deref(htabv,1) = GCweakvll;
     305  GCweakvll = htabv;
     306}
    192307
    193308
     
    202317    weak_value = ((flags & nhash_weak_value_mask) != 0);
    203318  int
    204     skip = (sizeof(hash_table_vector_header)/sizeof(LispObj))-1,
     319    skip = hash_table_vector_header_count-1,
    205320    key_tag,
    206321    val_tag,
     
    304419 
    305420void
    306 markhtabvs()
     421traditional_markhtabvs()
    307422{
    308423  LispObj this, header, pending;
     
    342457            marked_new = true;
    343458          }
    344         } else {
    345           deref(this,1) = (LispObj)NULL;
    346           for (i = 2; i <= elements; i++) {
    347             mark_root(deref(this,i));
    348           }
    349459        }
    350460      } else {
     
    373483    } else {
    374484      reaphashv(this);
     485    }
     486  }
     487
     488  /* Finally, mark the termination lists in all terminatable weak vectors
     489     They are now linked together on GCweakvll.
     490     This is where to store  lisp_global(TERMINATION_LIST) if we decide to do that,
     491     but it will force terminatable popualations to hold on to each other
     492     (set TERMINATION_LIST before clearing GCweakvll, and don't clear deref(this,1)).
     493     */
     494  pending = GCweakvll;
     495  GCweakvll = (LispObj)NULL;
     496  while (pending) {
     497    this = pending;
     498    pending = deref(this,1);
     499    deref(this,1) = (LispObj)NULL;
     500    mark_root(deref(this,1+3));
     501  }
     502}
     503
     504void
     505ncircle_markhtabvs()
     506{
     507  LispObj this, header, pending = 0;
     508  int subtag;
     509  bitvector markbits = GCmarkbits;
     510  hash_table_vector_header *hashp;
     511  Boolean marked_new;
     512
     513  /* First, process any weak hash tables that may have
     514     been encountered by the link-inverting marker; we
     515     should have more stack space now. */
     516
     517  while (GCdwsweakvll) {
     518    this = GCdwsweakvll;
     519    GCdwsweakvll = deref(this,1);
     520    ncircle_mark_weak_htabv(this);
     521  }
     522
     523  while (GCweakvll) {
     524    this = GCweakvll;
     525    GCweakvll = deref(this,1);
     526     
     527    header = header_of(this);
     528    subtag = header_subtag(header);
     529     
     530    if (subtag == subtag_weak) {
     531      natural weak_type = deref(this,2);
     532      deref(this,1) = pending;
     533      pending = this;
     534      if ((weak_type & population_type_mask) == population_weak_alist) {
     535        if (mark_weak_alist(this, weak_type)) {
     536          marked_new = true;
     537          }
     538      }
     539    } else if (subtag == subtag_hash_vector) {
     540      reaphashv(this);
     541    }
     542  }
     543
     544  /* Now, everything's marked that's going to be,  and "pending" is a list
     545     of populations.  CDR down that list and free
     546     anything that isn't marked.
     547     */
     548
     549  while (pending) {
     550    this = pending;
     551    pending = deref(this,1);
     552    deref(this,1) = (LispObj)NULL;
     553
     554    subtag = header_subtag(header_of(this));
     555    if (subtag == subtag_weak) {
     556      reapweakv(this);
     557    } else {
     558      Bug(NULL, "Bad object on pending list: %s\n", this);
    375559    }
    376560  }
     
    564748#endif
    565749
     750
     751weak_mark_fun dws_mark_weak_htabv = traditional_dws_mark_htabv;
     752weak_mark_fun mark_weak_htabv = traditional_mark_weak_htabv;
     753weak_process_fun markhtabvs = traditional_markhtabvs;
     754
     755void
     756install_weak_mark_functions(natural set) {
     757  switch(set) {
     758  case 0:
     759  default:
     760    dws_mark_weak_htabv = traditional_dws_mark_htabv;
     761    mark_weak_htabv = traditional_mark_weak_htabv;
     762    markhtabvs = traditional_markhtabvs;
     763    break;
     764  case 1:
     765    dws_mark_weak_htabv = ncircle_dws_mark_htabv;
     766    mark_weak_htabv = ncircle_mark_weak_htabv;
     767    markhtabvs = ncircle_markhtabvs;
     768    break;
     769  }
     770}
     771
    566772LispObj
    567773node_forwarding_address(LispObj node)
     
    612818forward_gcable_ptrs()
    613819{
    614   LispObj *prev = &(lisp_global(GCABLE_POINTERS)), next;
     820  LispObj *prev = &(lisp_global(GCABLE_POINTERS)), next, new;
    615821
    616822  while ((next = *prev) != (LispObj)NULL) {
    617     *prev = node_forwarding_address(next);
     823    new = node_forwarding_address(next);
     824    if (new != next) {
     825      *prev = new;
     826    }
    618827    prev = &(((xmacptr *)ptr_from_lispobj(untag(next)))->link);
    619828  }
     
    778987*/
    779988
    780 
     989#ifdef WINDOWS
     990#define get_time(when) /* FIXME */
     991#else
    781992#define get_time(when) gettimeofday(&when, NULL)
    782 
     993#endif
    783994
    784995
     
    786997#warning recursive marker disabled for testing; remember to re-enable it
    787998#endif
     999
    7881000
    7891001void
     
    7941006  area *a = active_dynamic_area, *to = NULL, *from = NULL, *note = NULL;
    7951007  unsigned timeidx = 1;
     1008  paging_info paging_info_start;
    7961009  xframe_list *x;
    7971010  LispObj
     
    8011014  TCR *other_tcr;
    8021015  natural static_dnodes;
     1016
     1017  install_weak_mark_functions(lisp_global(WEAK_GC_METHOD) >> fixnumshift);
     1018
     1019
    8031020
    8041021#ifndef FORCE_DWS_MARK
     
    8461063
    8471064  if (GCverbose) {
     1065    char buf[16];
     1066
     1067    sample_paging_info(&paging_info_start);
     1068    comma_output_decimal(buf,16,area_dnode(oldfree,a->low) << dnode_shift);
    8481069    if (GCephemeral_low) {
    8491070      fprintf(stderr,
     
    8531074      fprintf(stderr,"\n\n;;; Starting full GC");
    8541075    }
    855     fprintf(stderr, ",  %ld bytes allocated.\n", area_dnode(oldfree,a->low) << dnode_shift);
     1076    fprintf(stderr, ", %s bytes allocated.\n", buf);
    8561077  }
    8571078
     
    9081129      }
    9091130    }
     1131
     1132    mark_root(lisp_global(STATIC_CONSES));
    9101133
    9111134    {
     
    11461369      *( (long long *) ptr_from_lispobj(((macptr *) ptr_from_lispobj(untag(val)))->address)) += justfreed;
    11471370      if (GCverbose) {
     1371        char buf[16];
     1372        paging_info paging_info_stop;
     1373
     1374        sample_paging_info(&paging_info_stop);
    11481375        if (justfreed <= heap_segment_size) {
    11491376          justfreed = 0;
    11501377        }
     1378        comma_output_decimal(buf,16,justfreed);
    11511379        if (note == tenured_area) {
    1152           fprintf(stderr,";;; Finished full GC.  Freed %lld bytes in %d.%06d s\n\n", justfreed, elapsed.tv_sec, elapsed.tv_usec);
     1380          fprintf(stderr,";;; Finished full GC. %s bytes freed in %d.%06d s\n\n", buf, elapsed.tv_sec, elapsed.tv_usec);
    11531381        } else {
    1154           fprintf(stderr,";;; Finished Ephemeral GC of generation %d.  Freed %lld bytes in %d.%06d s\n\n",
     1382          fprintf(stderr,";;; Finished EGC of generation %d. %s bytes freed in %d.%06d s\n\n",
    11551383                  (from == g2_area) ? 2 : (from == g1_area) ? 1 : 0,
    1156                   justfreed,
     1384                  buf,
    11571385                  elapsed.tv_sec, elapsed.tv_usec);
    11581386        }
    1159       }
    1160     }
    1161   }
    1162 }
     1387        report_paging_info_delta(stderr, &paging_info_start, &paging_info_stop);
     1388      }
     1389    }
     1390  }
     1391}
  • branches/working-0711-perf/ccl/lisp-kernel/gc.h

    r7644 r9701  
    112112#endif
    113113
     114#ifdef DARWIN
     115#include <mach/task_info.h>
     116typedef struct task_events_info paging_info;
     117#else
     118#ifndef WINDOWS
     119#include <sys/resource.h>
     120typedef struct rusage paging_info;
     121#else
     122typedef natural paging_info;
     123#endif
     124#endif
     125
     126#include <stdio.h>
     127
     128void sample_paging_info(paging_info *);
     129void report_paging_info_delta(FILE*, paging_info *, paging_info *);
     130
    114131
    115132#define GC_TRAP_FUNCTION_IMMEDIATE_GC (-1)
     
    132149LispObj GCarealow, GCareadynamiclow;
    133150natural GCndnodes_in_area, GCndynamic_dnodes_in_area;
    134 LispObj GCweakvll;
     151LispObj GCweakvll,GCdwsweakvll;
    135152LispObj GCephemeral_low;
    136153natural GCn_ephemeral_dnodes;
     
    150167Boolean mark_weak_hash_vector(hash_table_vector_header *hashp, natural elements);
    151168Boolean mark_weak_alist(LispObj weak_alist, int weak_type);
    152 void markhtabvs(void);
    153169void mark_tcr_tlb(TCR *);
    154170void mark_tcr_xframes(TCR *);
     
    170186/* backend-interface */
    171187
     188typedef void (*weak_mark_fun) (LispObj);
     189weak_mark_fun mark_weak_htabv, dws_mark_weak_htabv;
     190
     191typedef void (*weak_process_fun)(void);
     192
     193weak_process_fun markhtabvs;
     194
     195
     196#define hash_table_vector_header_count (sizeof(hash_table_vector_header)/sizeof(LispObj))
     197
    172198void mark_root(LispObj);
     199void rmark(LispObj);
    173200void mark_xp(ExceptionInformation *);
    174201LispObj dnode_forwarding_address(natural, int);
     
    187214void forward_cstack_area(area *);
    188215LispObj compact_dynamic_heap(void);
    189 LispObj * skip_over_ivector(natural, LispObj);
    190216int purify(TCR *, signed_natural);
    191217int impurify(TCR *, signed_natural);
  • branches/working-0711-perf/ccl/lisp-kernel/image.c

    r8662 r9701  
    2222#include <errno.h>
    2323#include <unistd.h>
     24#ifndef WINDOWS
    2425#include <sys/mman.h>
     26#endif
    2527#include <stdio.h>
    2628
     
    161163}
    162164
     165#ifdef WINDOWS
     166void
     167load_image_section(int fd, openmcl_image_section_header *sect)
     168{
     169}
     170#else
    163171void
    164172load_image_section(int fd, openmcl_image_section_header *sect)
     
    234242  lseek(fd, pos+advance, SEEK_SET);
    235243}
    236    
     244#endif
     245
     246#ifdef WINDOWS
     247LispObj
     248load_openmcl_image(int fd, openmcl_image_file_header *h)
     249{
     250}
     251#else
    237252LispObj
    238253load_openmcl_image(int fd, openmcl_image_file_header *h)
     
    304319        break;
    305320      case AREA_DYNAMIC:
    306         lisp_global(HEAP_START) = ptr_to_lispobj(a->low);
    307         lisp_global(HEAP_END) = ptr_to_lispobj(a->high);
    308321        if (bias) {
    309322          relocate_area_contents(a, bias);
     
    317330  return image_nil;
    318331}
    319      
     332#endif
     333 
    320334void
    321335prepare_to_write_dynamic_space()
     
    469483    case GC_NUM:
    470484    case STATIC_CONSES:
     485    case WEAK_GC_METHOD:
    471486      break;
    472487    default:
     
    515530  trailer.delta = (int) (header_pos-eof_pos);
    516531  if (write(fd, &trailer, sizeof(trailer)) == sizeof(trailer)) {
     532#ifndef WINDOWS
    517533    fsync(fd);
     534#endif
    518535    close(fd);
    519536    return 0;
  • branches/working-0711-perf/ccl/lisp-kernel/image.h

    r7759 r9701  
    4343
    4444typedef struct {
    45   unsigned long code;
     45  natural code;
    4646  area *area;
    47   unsigned long memory_size;
    48   unsigned long static_dnodes;
     47  natural memory_size;
     48  natural static_dnodes;
    4949} openmcl_image_section_header;
    5050
     
    9090
    9191
    92 #define ABI_VERSION_MIN 1018
    93 #define ABI_VERSION_CURRENT 1018
    94 #define ABI_VERSION_MAX 1018
     92#define ABI_VERSION_MIN 1022
     93#define ABI_VERSION_CURRENT 1022
     94#define ABI_VERSION_MAX 1022
    9595
    9696#define NUM_IMAGE_SECTIONS 4    /* used to be 3 */
  • branches/working-0711-perf/ccl/lisp-kernel/lisp-debug.c

    r7752 r9701  
    8080    case EOF:
    8181      if (ferror(stdin)) {
    82         if (errno == EINTR) {
     82        if ((errno == EINTR) || (errno == EIO)) {
    8383          continue;
    8484        }
  • branches/working-0711-perf/ccl/lisp-kernel/lisp-errors.h

    r7624 r9701  
    2828#define error_too_many_values 7
    2929#define error_propagate_suspend 10
     30#define error_interrupt 11
     31#define error_suspend 12
     32#define error_suspend_all 13
     33#define error_resume 14
     34#define error_resume_all 15                                     
    3035#define error_cant_call 17
    3136
  • branches/working-0711-perf/ccl/lisp-kernel/lisp.h

    r6900 r9701  
    3737extern int page_size, log2_page_size;
    3838
    39 static inline unsigned long
    40 _align_to_power_of_2(unsigned long n, unsigned power)
     39static inline natural
     40_align_to_power_of_2(natural n, unsigned power)
    4141{
    42   unsigned long align = (1<<power) -1;
     42  natural align = (1<<power) -1;
    4343
    4444  return (n+align) & ~align;
    4545}
    4646
    47 #define align_to_power_of_2(n,p) _align_to_power_of_2(((unsigned long)(n)),p)
     47#define align_to_power_of_2(n,p) _align_to_power_of_2(((natural)(n)),p)
    4848
    49 static inline unsigned long
    50 _truncate_to_power_of_2(unsigned long n, unsigned power)
     49static inline natural
     50_truncate_to_power_of_2(natural n, unsigned power)
    5151{
    5252  return n & ~((1<<power) -1);
    5353}
    5454
    55 #define truncate_to_power_of_2(n,p) _truncate_to_power_of_2((unsigned long)(n),p)
     55#define truncate_to_power_of_2(n,p) _truncate_to_power_of_2((natural)(n),p)
    5656
    5757LispObj start_lisp(TCR*, LispObj);
     
    7373#define PLATFORM_OS_DARWIN 3
    7474#define PLATFORM_OS_FREEBSD 4
     75#define PLATFORM_OS_WINDOWS 6
    7576
    7677#ifdef LINUX
     
    8889#ifdef SOLARIS
    8990#define PLATFORM_OS PLATFORM_OS_SOLARIS
     91#endif
     92
     93#ifdef WINDOWS
     94#define PLATFORM_OS PLATFORM_OS_WINDOWS
    9095#endif
    9196
  • branches/working-0711-perf/ccl/lisp-kernel/lisp_globals.h

    r7624 r9701  
    6666#define BATCH_FLAG (-44)        /* -b arg */
    6767#define UNWIND_RESUME (-45)     /* address of _Unwind_Resume from libobjc */
    68 #define BAD_FPSCR_SAVE_HIGH (-46)       /* high word of FP reg used to save FPSCR */
     68#define WEAK_GC_METHOD (-46)    /* weak GC algorithm */
    6969#define IMAGE_NAME (-47)        /* --image-name arg */
    7070#define INITIAL_TCR (-48)       /* initial thread tcr */
  • branches/working-0711-perf/ccl/lisp-kernel/lisptypes.h

    r7828 r9701  
    102102#define UC_MCONTEXT(UC) UC->uc_mcontext
    103103#endif /* WORD_SIZE */
    104 #ifndef __DARWIN_UNIX03
    105 #define __DARWIN_UNIX03 0
    106 #endif
    107 #if !__DARWIN_UNIX03
    108 #define __ss ss
    109 #define __es es
    110 #define __fs fs
    111 #define __vs vs
    112104
    113 #define __r0 r0
    114 #define __r1 r1
    115 #define __r3 r3
    116 #define __r4 r4
    117 #define __r5 r5
    118 #define __r6 r6
    119 #define __r13 r13
    120 #define __srr0 srr0
    121 #define __srr1 srr1
    122 #define __lr lr
    123 #define __ctr ctr
    124 #define __xer xer
    125 #define __cr cr
    126 #define __dsisr dsisr
    127 #define __dar dar
    128 #define __exception exception
    129 #define __fpscr fpscr
    130 #define __fpregs fpregs
    131 #endif
     105
     106
    132107#endif /* PPC */
    133108
  • branches/working-0711-perf/ccl/lisp-kernel/m4macros.m4

    r7828 r9701  
    8383
    8484define([_emit_BSD_source_line_stab],[
     85ifdef([X86],[
     86# __line__ "__file__" 1],[
    8587        .stabd 68,0,$1
    86 ])
     88])])
    8789
    8890
     
    110112define([emit_source_line_stab],[
    111113        ifelse(eval(SYSstabs),
    112                eval(BSDstabs),
     114             eval(BSDstabs),
    113115              [_emit_BSD_source_line_stab($1)],
    114116              eval(SYSstabs),
     
    121123
    122124
     125
    123126/*  Assemble a reference to the high half of a 32-bit constant,  */
    124127/*  possibly adjusted for sign-extension of thw low half.  */
     
    189192])
    190193        .set func_start,$1
    191        
    192 ])
     194# __line__ "__file__" 1 ])
    193195
    194196
     
    279281
    280282define([__],[emit_source_line_stab(__line__)
    281 # __line__
    282283        $@
    283284        ])
  • branches/working-0711-perf/ccl/lisp-kernel/memory.c

    r7137 r9701  
    3232#endif
    3333
    34 
     34#ifndef WINDOWS
    3535#include <sys/mman.h>
     36#endif
    3637
    3738void
     
    7576
    7677int
    77 ProtectMemory(LogicalAddress addr, int nbytes)
     78ProtectMemory(LogicalAddress addr, natural nbytes)
    7879{
    7980  int status = mprotect(addr, nbytes, PROT_READ | PROT_EXEC);
     
    8788
    8889int
    89 UnProtectMemory(LogicalAddress addr, int nbytes)
     90UnProtectMemory(LogicalAddress addr, natural nbytes)
    9091{
    9192  return mprotect(addr, nbytes, PROT_READ|PROT_WRITE|PROT_EXEC);
     
    179180zero_memory_range(BytePtr start, BytePtr end)
    180181{
    181   bzero(start,end-start);
     182#ifdef WINDOWS
     183  ZeroMemory(start,end-start);
     184#else
     185  bzero(start,(size_t)(end-start));
     186#endif
    182187}
    183188
     
    611616}
    612617
     618#ifdef WINDOWS
     619void
     620release_readonly_area()
     621{
     622}
     623#else
     624void
     625release_readonly_area()
     626{
     627  area *a = readonly_area;
     628  munmap(a->low,align_to_power_of_2(a->active-a->low, log2_page_size));
     629  a->active = a->low;
     630  a->ndnodes = 0;
     631  pure_space_active = pure_space_start;
     632}
     633#endif
  • branches/working-0711-perf/ccl/lisp-kernel/memprotect.h

    r7828 r9701  
    3030
    3131int
    32 ProtectMemory(LogicalAddress, int);
     32ProtectMemory(LogicalAddress, natural);
    3333
    3434int
    35 UnProtectMemory(LogicalAddress, int);
     35UnProtectMemory(LogicalAddress, natural);
    3636
    3737typedef enum {
  • branches/working-0711-perf/ccl/lisp-kernel/pmcl-kernel.c

    r7668 r9701  
    3131#include <stdio.h>
    3232#include <stdlib.h>
     33#ifndef WINDOWS
    3334#include <sys/mman.h>
     35#endif
    3436#include <fcntl.h>
    3537#include <signal.h>
     38#include <errno.h>
     39#ifndef WINDOWS
     40#include <sys/utsname.h>
    3641#include <unistd.h>
    37 #include <errno.h>
    38 #include <sys/utsname.h>
     42#endif
    3943
    4044#ifdef LINUX
     
    106110
    107111#include <ctype.h>
     112#ifndef WINDOWS
    108113#include <sys/select.h>
     114#endif
    109115#include "Threads.h"
     116
     117#include <fenv.h>
    110118
    111119#ifndef MAP_NORESERVE
     
    141149{
    142150  void * cache_start = (void *) p;
    143   unsigned long ncacheflush = (unsigned long) q - (unsigned long) p;
     151  natural ncacheflush = (natural) q - (natural) p;
    144152
    145153  xMakeDataExecutable(cache_start, ncacheflush); 
     
    149157ensure_stack_limit(size_t stack_size)
    150158{
     159#ifdef WINDOWS
     160#else
    151161  struct rlimit limits;
    152162  rlim_t cur_stack_limit, max_stack_limit;
     
    168178    }
    169179  }
     180#endif
    170181  return stack_size;
    171182}
     
    189200  void *allocate_stack(unsigned);
    190201  void free_stack(void *);
    191   unsigned size = useable+softsize+hardsize;
    192   unsigned overhead;
     202  natural size = useable+softsize+hardsize;
     203  natural overhead;
    193204  BytePtr base, softlimit, hardlimit;
    194205  OSErr err;
     
    228239  }
    229240  if (base_p) *base_p = base;
    230   return (BytePtr) ((unsigned long)(base+size));
     241  return (BytePtr) ((natural)(base+size));
    231242}
    232243
     
    277288register_cstack_holding_area_lock(BytePtr bottom, natural size)
    278289{
    279   BytePtr lowlimit = (BytePtr) (((((unsigned long)bottom)-size)+4095)&~4095);
     290  BytePtr lowlimit = (BytePtr) (((((natural)bottom)-size)+4095)&~4095);
    280291  area *a = new_area((BytePtr) bottom-size, bottom, AREA_CSTACK);
    281292  a->hardlimit = lowlimit+CSTACK_HARDPROT;
     
    351362#endif
    352363#endif
     364#ifdef WINDOWS
     365#define MAXIMUM_MAPPABLE_MEMORY (512<<30LL)
     366#endif
    353367#else
    354368#ifdef DARWIN
     
    408422*/
    409423
     424#ifdef WINDOWS
     425void
     426uncommit_pages(void *start, size_t len)
     427{
     428}
     429#else
    410430void
    411431uncommit_pages(void *start, size_t len)
     
    425445  }
    426446}
     447#endif
    427448
    428449#define TOUCH_PAGES_ON_COMMIT 0
     
    446467}
    447468
     469#ifdef WINDOWS
     470Boolean
     471commit_pages(void *start, size_t len)
     472{
     473}
     474#else
    448475Boolean
    449476commit_pages(void *start, size_t len)
     
    477504  }
    478505}
     506#endif
    479507
    480508area *
     
    491519}
    492520
     521#ifdef WINDOWS
     522area *
     523extend_readonly_area(unsigned more)
     524{
     525}
     526#else
    493527area *
    494528extend_readonly_area(unsigned more)
     
    502536      return NULL;
    503537    }
    504     mask = ((unsigned long)a->active) & (page_size-1);
     538    mask = ((natural)a->active) & (page_size-1);
    505539    if (mask) {
    506540      UnProtectMemory(a->active-mask, page_size);
     
    520554  return NULL;
    521555}
     556#endif
    522557
    523558LispObj image_base=0;
     
    587622
    588623
    589 
     624#ifdef WINDOWS
    590625area *
    591 create_reserved_area(unsigned long totalsize)
     626create_reserved_area(natural totalsize)
     627{
     628}
     629#else
     630area *
     631create_reserved_area(natural totalsize)
    592632{
    593633  OSErr err;
     
    659699  if (start != want) {
    660700    munmap(start, totalsize+heap_segment_size);
    661     start = (void *)((((unsigned long)start)+heap_segment_size-1) & ~(heap_segment_size-1));
     701    start = (void *)((((natural)start)+heap_segment_size-1) & ~(heap_segment_size-1));
    662702    if(mmap(start, totalsize, PROT_NONE, MAP_PRIVATE | MAP_ANON | MAP_FIXED | MAP_NORESERVE, -1, 0) != start) {
    663703      return NULL;
     
    667707
    668708  h = (Ptr) start;
    669   base = (unsigned long) start;
     709  base = (natural) start;
    670710  image_base = base;
    671711  lastbyte = (BytePtr) (start+totalsize);
     
    681721  */
    682722  end = lastbyte;
    683   end = (BytePtr) ((unsigned long)((((unsigned long)end) - ((totalsize+63)>>6)) & ~4095));
     723  end = (BytePtr) ((natural)((((natural)end) - ((totalsize+63)>>6)) & ~4095));
    684724
    685725  global_mark_ref_bits = (bitvector)end;
    686   end = (BytePtr) ((unsigned long)((((unsigned long)end) - ((totalsize+63) >> 6)) & ~4095));
     726  end = (BytePtr) ((natural)((((natural)end) - ((totalsize+63) >> 6)) & ~4095));
    687727  global_reloctab = (LispObj *) end;
    688728  reserved = new_area(start, end, AREA_VOID);
     
    693733  return reserved;
    694734}
    695 
     735#endif
    696736
    697737void *
     
    762802  a->softprot = NULL;
    763803  a->hardprot = NULL;
     804  lisp_global(HEAP_START) = ptr_to_lispobj(a->low);
     805  lisp_global(HEAP_END) = ptr_to_lispobj(a->high);
    764806  ensure_gc_structures_writable();
    765807  return a;
     
    848890    p += (1+strlen(p));
    849891  }
    850   return (BytePtr)((((unsigned long) p) +4095) & ~4095);
     892  return (BytePtr)((((natural) p) +4095) & ~4095);
    851893}
    852894
     
    11541196           thread_stack_size = stack_size;
    11551197          }
    1156           if (thread_stack_size >= (1L<<((WORD_SIZE-fixnumshift)-1))) {
    1157             thread_stack_size = (1L<<((WORD_SIZE-fixnumshift)-1))-1;
     1198          if (thread_stack_size >= (1LL<<((WORD_SIZE-fixnumshift)-1))) {
     1199            thread_stack_size = (1LL<<((WORD_SIZE-fixnumshift)-1))-1;
    11581200          }
    11591201         
     
    11891231}
    11901232
     1233#ifdef WINDOWS
     1234void
     1235terminate_lisp()
     1236{
     1237}
     1238#else
    11911239pid_t main_thread_pid = (pid_t)0;
    11921240
     
    11971245  _exit(-1);
    11981246}
     1247#endif
    11991248
    12001249#ifdef DARWIN
     
    12671316
    12681317#ifdef X8664
     1318#ifdef WINDOWS
     1319void
     1320remap_spjump()
     1321{
     1322}
     1323#else
    12691324void
    12701325remap_spjump()
     
    12851340}
    12861341#endif
     1342#endif
    12871343
    12881344void
    12891345check_os_version(char *progname)
    12901346{
     1347#ifdef WINDOWS
     1348#else
    12911349  struct utsname uts;
    12921350
     
    13081366#endif
    13091367#endif
     1368#endif
    13101369}
    13111370
     
    13151374  probably complain if we don't have (at least) SSE2.
    13161375*/
    1317 extern int cpuid(int, int*, int*, int*);
     1376extern int cpuid(natural, natural*, natural*, natural*);
    13181377
    13191378#define X86_FEATURE_CMOV    (1<<15)
     
    13281387check_x86_cpu()
    13291388{
    1330   int eax, ebx, ecx, edx;
     1389  natural eax, ebx, ecx, edx;
    13311390 
    13321391  eax = cpuid(0, &ebx, &ecx, &edx);
     
    13821441#endif
    13831442
     1443Boolean
     1444bogus_fp_exceptions = false;
     1445
     1446typedef
     1447float (*float_arg_returns_float)(float);
     1448
     1449float
     1450fcallf(float_arg_returns_float fun, float arg)
     1451{
     1452  return fun(arg);
     1453}
     1454
     1455void
     1456check_bogus_fp_exceptions()
     1457{
     1458#ifdef X8664
     1459  float asinf(float),result;
     1460   
     1461
     1462  natural save_mxcsr = get_mxcsr(), post_mxcsr;
     1463  set_mxcsr(0x1f80);
     1464
     1465  result = fcallf(asinf, 1.0);
     1466  post_mxcsr = get_mxcsr();
     1467  set_mxcsr(save_mxcsr);
     1468  if (post_mxcsr & (FE_ALL_EXCEPT & (~FE_INEXACT))) {
     1469    bogus_fp_exceptions = true;
     1470  }
     1471#endif
     1472}
     1473
    13841474main(int argc, char *argv[], char *envp[], void *aux)
    13851475{
     
    14011491  page_size = getpagesize();
    14021492
     1493  check_bogus_fp_exceptions();
    14031494#ifdef LINUX
    14041495#ifdef X8664
     
    14691560#endif
    14701561
     1562#ifndef WINDOWS
    14711563  main_thread_pid = getpid();
     1564#endif
    14721565  tcr_area_lock = (void *)new_recursive_lock();
    14731566
     
    14971590  lisp_global(TCR_AREA_LOCK) = ptr_to_lispobj(tcr_area_lock);
    14981591
     1592#ifdef X8664
     1593  lisp_global(SUBPRIMS_BASE) = (LispObj)((1<<16)+(5<<10));
     1594#else
    14991595  lisp_global(SUBPRIMS_BASE) = (LispObj)(5<<10);
     1596#endif
    15001597  lisp_global(RET1VALN) = (LispObj)&ret1valn;
    15011598  lisp_global(LEXPR_RETURN) = (LispObj)&nvalret;
     
    15751672#endif
    15761673  tcr->prev = tcr->next = tcr;
     1674#ifndef WINDOWS
    15771675  lisp_global(INTERRUPT_SIGNAL) = (LispObj) box_fixnum(SIGNAL_FOR_PROCESS_INTERRUPT);
     1676#endif
    15781677  tcr->vs_area->active -= node_size;
    15791678  *(--tcr->save_vsp) = nrs_TOPLFUNC.vcell;
     
    16061705{
    16071706  extern void flush_cache_lines();
    1608   unsigned long ustart = (unsigned long) start, base, end;
     1707  natural ustart = (natural) start, base, end;
    16091708 
    16101709  base = (ustart) & ~(cache_block_size-1);
     
    16311730
    16321731#ifndef DARWIN
     1732#ifdef WINDOWS
    16331733void *
    16341734xGetSharedLibrary(char *path, int mode)
    16351735{
     1736}
     1737#else
     1738void *
     1739xGetSharedLibrary(char *path, int mode)
     1740{
    16361741  return dlopen(path, mode);
    16371742}
     1743#endif
    16381744#else
    16391745void *
     
    17631869}
    17641870
     1871#ifdef WINDOWS
    17651872int
    17661873do_fd_is_set(int fd, fd_set *fdsetp)
    17671874{
     1875}
     1876#else
     1877int
     1878do_fd_is_set(int fd, fd_set *fdsetp)
     1879{
    17681880  return FD_ISSET(fd,fdsetp);
    17691881}
     1882#endif
    17701883
    17711884void
     
    18121925  }
    18131926  if (image_nil == 0) {
    1814     fprintf(stderr, "Couldn't load lisp heap image from %s\n", path);
     1927    fprintf(stderr, "Couldn't load lisp heap image from %s:\n%s\n", path, strerror(errno));
    18151928    exit(-1);
    18161929  }
     
    18801993
    18811994
     1995#ifdef DARWIN
     1996void
     1997sample_paging_info(paging_info *stats)
     1998{
     1999  mach_msg_type_number_t count = TASK_EVENTS_INFO_COUNT;
     2000
     2001  task_info(mach_task_self(),
     2002            TASK_EVENTS_INFO,
     2003            (task_info_t)stats,
     2004            &count);
     2005}
     2006
     2007void
     2008report_paging_info_delta(FILE *out, paging_info *start, paging_info *stop)
     2009{
     2010  fprintf(out,";;; %d soft faults, %d faults, %d pageins\n\n",
     2011          stop->cow_faults-start->cow_faults,
     2012          stop->faults-start->faults,
     2013          stop->pageins-start->pageins);
     2014}
     2015
     2016#else
     2017#ifdef WINDOWS
     2018void
     2019sample_paging_info(paging_info *stats)
     2020{
     2021}
     2022
     2023void
     2024report_paging_info_delta(FILE *out, paging_info *start, paging_info *stop)
     2025{
     2026}
     2027#else
     2028void
     2029sample_paging_info(paging_info *stats)
     2030{
     2031  getrusage(RUSAGE_SELF, stats);
     2032}
     2033
     2034void
     2035report_paging_info_delta(FILE *out, paging_info *start, paging_info *stop)
     2036{
     2037  fprintf(out,";;; %d soft faults, %d faults, %d pageins\n\n",
     2038          stop->ru_minflt-start->ru_minflt,
     2039          stop->ru_majflt-start->ru_majflt,
     2040          stop->ru_nswap-start->ru_nswap);
     2041}
     2042
     2043#endif
     2044#endif
  • branches/working-0711-perf/ccl/lisp-kernel/ppc-exceptions.c

    r7668 r9701  
    442442        /*        nrs_GC_EVENT_STATUS_BITS.vcell |= gc_integrity_check_bit; */
    443443        gc_from_xp(xp, 0L);
     444        release_readonly_area();
    444445      }
    445446      if (selector & GC_TRAP_FUNCTION_PURIFY) {
     
    806807   do_hard_stack_overflow,   
    807808   do_hard_stack_overflow,
    808    do_hard_stack_overflow,
     809   do_hard_stack_overflow
    809810   };
    810811
     
    905906      handler = protection_handlers[area->why];
    906907      return handler(xp, area, addr);
     908    } else {
     909      if ((addr >= readonly_area->low) &&
     910          (addr < readonly_area->active)) {
     911        UnProtectMemory((LogicalAddress)(truncate_to_power_of_2(addr,log2_page_size)),
     912                        page_size);
     913        return 0;
     914      }
    907915    }
    908916  }
     
    10881096  return -1;
    10891097}
     1098
    10901099
    10911100/*
     
    13271336
    13281337  case UUO_INTERR:
    1329     if (errnum == error_propagate_suspend) {
     1338    {
     1339      TCR * target = (TCR *)xpGPR(xp,arg_z);
    13301340      status = 0;
    1331     } else {
    1332       status = handle_error(xp, errnum, rb, 0,  where);
     1341      switch (errnum) {
     1342      case error_propagate_suspend:
     1343        break;
     1344      case error_interrupt:
     1345        xpGPR(xp,imm0) = (LispObj) raise_thread_interrupt(target);
     1346        break;
     1347      case error_suspend:
     1348        xpGPR(xp,imm0) = (LispObj) lisp_suspend_tcr(target);
     1349        break;
     1350      case error_suspend_all:
     1351        lisp_suspend_other_threads();
     1352        break;
     1353      case error_resume:
     1354        xpGPR(xp,imm0) = (LispObj) lisp_resume_tcr(target);
     1355        break;
     1356      case error_resume_all:
     1357        lisp_resume_other_threads();
     1358        break;
     1359      default:
     1360        status = handle_error(xp, errnum, rb, 0,  where);
     1361        break;
     1362      }
    13331363    }
    13341364    break;
     
    20952125  sigfillset(&sa.sa_mask);
    20962126  sa.sa_flags =
    2097     SA_RESTART
     2127    0 /* SA_RESTART */
    20982128    | SA_SIGINFO
    20992129#ifdef DARWIN
     
    21702200{
    21712201  thread_suspend_signal = SIG_SUSPEND_THREAD;
    2172   thread_resume_signal = SIG_RESUME_THREAD;
    21732202
    21742203  install_signal_handler(thread_suspend_signal, (void *) suspend_resume_handler);
    2175   install_signal_handler(thread_resume_signal,  (void *) suspend_resume_handler);
    21762204  install_signal_handler(SIGQUIT, (void *)quit_handler);
    21772205}
     
    23602388  kret = thread_set_state(thread,
    23612389                          PPC_FLOAT_STATE,
    2362                           (thread_state_t)&(mc->__fs),
     2390                          (thread_state_t)&(mc->fs),
    23632391                          PPC_FLOAT_STATE_COUNT);
    23642392
     
    23692397  kret = thread_set_state(thread,
    23702398                          PPC_THREAD_STATE64,
    2371                           (thread_state_t)&(mc->__ss),
     2399                          (thread_state_t)&(mc->ss),
    23722400                          PPC_THREAD_STATE64_COUNT);
    23732401#else
    23742402  kret = thread_set_state(thread,
    23752403                          MACHINE_THREAD_STATE,
    2376                           (thread_state_t)&(mc->__ss),
     2404                          (thread_state_t)&(mc->ss),
    23772405                          MACHINE_THREAD_STATE_COUNT);
    23782406#endif
     
    24472475    Bug(NULL, "Exception thread can't obtain thread state, Mach result = %d", result);
    24482476  }
    2449   stackp = ts.__r1;
     2477  stackp = ts.r1;
    24502478  backlink = stackp;
    24512479  stackp = TRUNC_DOWN(stackp, C_REDZONE_LEN, C_STK_ALIGN);
     
    24552483  stackp = TRUNC_DOWN(stackp, sizeof(*mc), C_STK_ALIGN);
    24562484  mc = (MCONTEXT_T) ptr_from_lispobj(stackp);
    2457   memmove(&(mc->__ss),&ts,sizeof(ts));
     2485  memmove(&(mc->ss),&ts,sizeof(ts));
    24582486
    24592487  thread_state_count = PPC_FLOAT_STATE_COUNT;
    24602488  thread_get_state(thread,
    24612489                   PPC_FLOAT_STATE,
    2462                    (thread_state_t)&(mc->__fs),
     2490                   (thread_state_t)&(mc->fs),
    24632491                   &thread_state_count);
    24642492
     
    24752503                   PPC_EXCEPTION_STATE,
    24762504#endif
    2477                    (thread_state_t)&(mc->__es),
     2505                   (thread_state_t)&(mc->es),
    24782506                   &thread_state_count);
    24792507
     
    25402568  */
    25412569
    2542   ts.__srr0 = (natural) handler_address;
    2543   ts.__srr1 = (int) xpMSR(pseudosigcontext) & ~MSR_FE0_FE1_MASK;
    2544   ts.__r1 = stackp;
    2545   ts.__r3 = signum;
    2546   ts.__r4 = (natural)pseudosigcontext;
    2547   ts.__r5 = (natural)tcr;
    2548   ts.__r6 = (natural)old_valence;
    2549   ts.__lr = (natural)pseudo_sigreturn;
     2570  ts.srr0 = (natural) handler_address;
     2571  ts.srr1 = (int) xpMSR(pseudosigcontext) & ~MSR_FE0_FE1_MASK;
     2572  ts.r1 = stackp;
     2573  ts.r3 = signum;
     2574  ts.r4 = (natural)pseudosigcontext;
     2575  ts.r5 = (natural)tcr;
     2576  ts.r6 = (natural)old_valence;
     2577  ts.lr = (natural)pseudo_sigreturn;
    25502578
    25512579
    25522580#ifdef PPC64
    2553   ts.__r13 = xpGPR(pseudosigcontext,13);
     2581  ts.r13 = xpGPR(pseudosigcontext,13);
    25542582  thread_set_state(thread,
    25552583                   PPC_THREAD_STATE64,
     
    26002628                   &thread_state_count);
    26012629  if (enabled) {
    2602     ts.__srr1 |= MSR_FE0_FE1_MASK;
     2630    ts.srr1 |= MSR_FE0_FE1_MASK;
    26032631  } else {
    2604     ts.__srr1 &= ~MSR_FE0_FE1_MASK;
     2632    ts.srr1 &= ~MSR_FE0_FE1_MASK;
    26052633  }
    26062634  /*
     
    26202648  */
    26212649  {
    2622     lisp_frame *tos = (lisp_frame *)ts.__r1,
     2650    lisp_frame *tos = (lisp_frame *)ts.r1,
    26232651      *next_frame = tos->backlink;
    26242652   
    26252653    if (tos == (next_frame -1)) {
    2626       ts.__srr0 = tos->savelr;
    2627       ts.__r1 = (LispObj) next_frame;
     2654      ts.srr0 = tos->savelr;
     2655      ts.r1 = (LispObj) next_frame;
    26282656    } else {
    2629       ts.__srr0 += 4;
     2657      ts.srr0 += 4;
    26302658    }
    26312659  }
  • branches/working-0711-perf/ccl/lisp-kernel/ppc-exceptions.h

    r6514 r9701  
    6868
    6969#ifdef DARWIN
    70 #define xpGPRvector(x) (&(UC_MCONTEXT(x)->__ss.__r0))
     70#define xpGPRvector(x) (&(UC_MCONTEXT(x)->ss.r0))
    7171#define xpGPR(x,gprno) ((xpGPRvector(x))[gprno])
    7272#define set_xpGPR(x,gpr,new) xpGPR((x),(gpr)) = (UInt32)(new)
    73 #define xpPC(x) (*((pc*) &(UC_MCONTEXT(x)->__ss.__srr0)))
     73#define xpPC(x) (*((pc*) &(UC_MCONTEXT(x)->ss.srr0)))
    7474#define set_xpPC(x,new) (xpPC(x) = (pc)(new))
    75 #define xpLR(x) (*((pc*)(&(UC_MCONTEXT(x)->__ss.__lr))))
    76 #define xpCTR(x) (*(pc*)(&(UC_MCONTEXT(x)->__ss.__ctr)))
    77 #define xpXER(x) (UC_MCONTEXT(x)->__ss.__xer)
    78 #define xpCCR(x) (UC_MCONTEXT(x)->__ss.__cr)
    79 #define xpMSR(x) (UC_MCONTEXT(x)->__ss.__srr1)
    80 #define xpDSISR(x) (UC_MCONTEXT(x)->__es.__dsisr)
    81 #define xpDAR(x) (UC_MCONTEXT(x)->__es.__dar)
    82 #define xpTRAP(x) (UC_MCONTEXT(x)->__es.__exception)
    83 #define xpFPSCR(x) (UC_MCONTEXT(x)->__fs.__fpscr)
    84 #define xpFPRvector(x) (UC_MCONTEXT(x)->__fs.__fpregs)
     75#define xpLR(x) (*((pc*)(&(UC_MCONTEXT(x)->ss.lr))))
     76#define xpCTR(x) (*(pc*)(&(UC_MCONTEXT(x)->ss.ctr)))
     77#define xpXER(x) (UC_MCONTEXT(x)->ss.xer)
     78#define xpCCR(x) (UC_MCONTEXT(x)->ss.cr)
     79#define xpMSR(x) (UC_MCONTEXT(x)->ss.srr1)
     80#define xpDSISR(x) (UC_MCONTEXT(x)->es.dsisr)
     81#define xpDAR(x) (UC_MCONTEXT(x)->es.dar)
     82#define xpTRAP(x) (UC_MCONTEXT(x)->es.exception)
     83#define xpFPSCR(x) (UC_MCONTEXT(x)->fs.fpscr)
     84#define xpFPRvector(x) (UC_MCONTEXT(x)->fs.fpregs)
    8585#define xpFPR(x,fprno) (xpFPRvector(x)[fprno])
    8686/* There's a bug in some versions of Darwin on G5 processors: FP context
     
    126126#define DarwinSigReturn(x)
    127127#else
    128 #define DarwinSigReturn(x) (UC_MCONTEXT(x)->__ss.__xer)^=0x80
     128#define DarwinSigReturn(x) (UC_MCONTEXT(x)->ss.xer)^=0x80
    129129#endif
    130130#endif
     
    408408
    409409#ifdef DARWIN
    410 #define SIGNAL_FOR_PROCESS_INTERRUPT SIGEMT
     410#define SIGNAL_FOR_PROCESS_INTERRUPT SIGUSR1
    411411#endif
    412412#ifdef LINUX
  • branches/working-0711-perf/ccl/lisp-kernel/ppc-gc.c

    r7668 r9701  
    303303          ((hash_table_vector_header *) base)->cache_key = undefined;
    304304          ((hash_table_vector_header *) base)->cache_value = lisp_nil;
    305         }
    306         deref(ptr_to_lispobj(base),1) = GCweakvll;
    307         GCweakvll = n;
    308         return;
     305          mark_weak_htabv(n);
     306          return;
     307        }
    309308      }
    310309
     
    563562          ((hash_table_vector_header *) base)->cache_key = undefined;
    564563          ((hash_table_vector_header *) base)->cache_value = lisp_nil;
    565         }
    566         deref(ptr_to_lispobj(base),1) = GCweakvll;
    567         GCweakvll = n;
    568         return;
     564          mark_weak_htabv(n);
     565          return;
     566        }
    569567      }
    570568
     
    732730          ((hash_table_vector_header *) base)->cache_key = undefined;
    733731          ((hash_table_vector_header *) base)->cache_value = lisp_nil;
    734         }
    735 
    736         deref(ptr_to_lispobj(base),1) = GCweakvll;
    737         GCweakvll = this;
    738         goto Climb;
     732          dws_mark_weak_htabv(this);
     733          element_count = hash_table_vector_header_count;
     734        }
    739735      }
    740736
     
    990986          ((hash_table_vector_header *) start)->cache_key = undefined;
    991987          ((hash_table_vector_header *) start)->cache_value = lisp_nil;
    992         }
    993 
    994         start[1] = GCweakvll;
    995         GCweakvll = (LispObj) (((natural) start) + fulltag_misc);
    996       } else {
    997 
    998         if (subtag == subtag_pool) {
    999           start[1] = lisp_nil;
    1000         }
    1001 
    1002         if (subtag == subtag_weak) {
    1003           natural weak_type = (natural) start[2];
    1004           if (weak_type >> population_termination_bit)
    1005             element_count -= 2;
    1006           else
    1007             element_count -= 1;
    1008           start[1] = GCweakvll;
    1009           GCweakvll = (LispObj) (((natural) start) + fulltag_misc);   
    1010         }
    1011 
    1012         base = start + element_count + 1;
    1013         while(element_count--) {
    1014           mark_root(*--base);
    1015         }
    1016       }
     988          mark_weak_htabv((LispObj)start);
     989          element_count = 0;
     990        }
     991      }
     992      if (subtag == subtag_pool) {
     993        start[1] = lisp_nil;
     994      }
     995
     996      if (subtag == subtag_weak) {
     997        natural weak_type = (natural) start[2];
     998        if (weak_type >> population_termination_bit)
     999          element_count -= 2;
     1000        else
     1001          element_count -= 1;
     1002        start[1] = GCweakvll;
     1003        GCweakvll = (LispObj) (((natural) start) + fulltag_misc);   
     1004      }
     1005
     1006      base = start + element_count + 1;
     1007      while(element_count--) {
     1008        mark_root(*--base);
     1009      }   
    10171010      start += size;
    10181011    }
     
    17361729
    17371730  /*
    1738      This assumes that it's getting called with a simple-{base,general}-string
    1739      or code vector as an argument and that there's room for the object in the
     1731     This assumes that it's getting called with an ivector
     1732     argument and that there's room for the object in the
    17401733     destination area.
    17411734  */
    17421735
    17431736
     1737LispObj
     1738purify_displaced_object(LispObj obj, area *dest, natural disp)
     1739{
     1740  BytePtr
     1741    free = dest->active,
     1742    *old = (BytePtr *) ptr_from_lispobj(untag(obj));
     1743  LispObj
     1744    header = header_of(obj),
     1745    new;
     1746  natural
     1747    start = (natural)old,
     1748    physbytes;
     1749
     1750  physbytes = ((natural)(skip_over_ivector(start,header))) - start;
     1751  dest->active += physbytes;
     1752
     1753  new = ptr_to_lispobj(free)+disp;
     1754
     1755  memcpy(free, (BytePtr)old, physbytes);
     1756  /* Leave a trail of breadcrumbs.  Or maybe just one breadcrumb. */
     1757  /* Actually, it's best to always leave a trail, for two reasons.
     1758     a) We may be walking the same heap that we're leaving forwaring
     1759     pointers in, so we don't want garbage that we leave behind to
     1760     look like a header.
     1761     b) We'd like to be able to forward code-vector locatives, and
     1762     it's easiest to do so if we leave a {forward_marker, dnode_locative}
     1763     pair at every doubleword in the old vector.
     1764  */
     1765  while(physbytes) {
     1766    *old++ = (BytePtr) forward_marker;
     1767    *old++ = (BytePtr) free;
     1768    free += dnode_size;
     1769    physbytes -= dnode_size;
     1770  }
     1771  return new;
     1772}
     1773
     1774LispObj
     1775purify_object(LispObj obj, area *dest)
     1776{
     1777  return purify_displaced_object(obj, dest, fulltag_of(obj));
     1778}
     1779
     1780
     1781
     1782void
     1783copy_ivector_reference(LispObj *ref, BytePtr low, BytePtr high, area *dest)
     1784{
     1785  LispObj obj = *ref, header;
     1786  natural tag = fulltag_of(obj), header_tag, header_subtag;
     1787
     1788  if ((tag == fulltag_misc) &&
     1789      (((BytePtr)ptr_from_lispobj(obj)) > low) &&
     1790      (((BytePtr)ptr_from_lispobj(obj)) < high)) {
     1791    header = deref(obj, 0);
     1792    if (header == forward_marker) { /* already copied */
     1793      *ref = (untag(deref(obj,1)) + tag);
     1794    } else {
     1795      header_tag = fulltag_of(header);
     1796      if (immheader_tag_p(header_tag)) {
     1797        if (header_subtag(header) != subtag_macptr) {
     1798          *ref = purify_object(obj, dest);
     1799        }
     1800      }
     1801    }
     1802  }
     1803}
     1804
     1805void
     1806purify_locref(LispObj *locaddr, BytePtr low, BytePtr high, area *to)
     1807{
     1808#ifdef PPC
    17441809  LispObj
    1745     purify_displaced_object(LispObj obj, area *dest, natural disp)
    1746   {
    1747     BytePtr
    1748       free = dest->active,
    1749       *old = (BytePtr *) ptr_from_lispobj(untag(obj));
    1750     LispObj
    1751       header = header_of(obj),
    1752       new;
    1753     natural
    1754       subtag = header_subtag(header),
    1755       element_count = header_element_count(header),
    1756       physbytes;
    1757 
    1758     switch(subtag) {
    1759     case subtag_simple_base_string:
    1760       physbytes = node_size + (element_count << 2);
    1761       break;
    1762 
    1763     case subtag_code_vector:
    1764       physbytes = node_size + (element_count << 2);
    1765       break;
    1766 
    1767     default:
    1768       Bug(NULL, "Can't purify object at 0x%08x", obj);
    1769       return obj;
    1770     }
    1771     physbytes = (physbytes+(dnode_size-1))&~(dnode_size-1);
    1772     dest->active += physbytes;
    1773 
    1774     new = ptr_to_lispobj(free)+disp;
    1775 
    1776     memcpy(free, (BytePtr)old, physbytes);
    1777     /* Leave a trail of breadcrumbs.  Or maybe just one breadcrumb. */
    1778     /* Actually, it's best to always leave a trail, for two reasons.
    1779        a) We may be walking the same heap that we're leaving forwaring
    1780        pointers in, so we don't want garbage that we leave behind to
    1781        look like a header.
    1782        b) We'd like to be able to forward code-vector locatives, and
    1783        it's easiest to do so if we leave a {forward_marker, dnode_locative}
    1784        pair at every doubleword in the old vector.
    1785     */
    1786     while(physbytes) {
    1787       *old++ = (BytePtr) forward_marker;
    1788       *old++ = (BytePtr) free;
    1789       free += dnode_size;
    1790       physbytes -= dnode_size;
    1791     }
    1792     return new;
    1793   }
    1794 
    1795   LispObj
    1796     purify_object(LispObj obj, area *dest)
    1797   {
    1798     return purify_displaced_object(obj, dest, fulltag_of(obj));
    1799   }
    1800 
    1801 
    1802 #define FORWARD_ONLY 0
    1803 #define COPY_CODE (1<<0)
    1804 #define COPY_STRINGS (1<<1)
    1805 
    1806   void
    1807     copy_ivector_reference(LispObj *ref, BytePtr low, BytePtr high, area *dest, int what_to_copy)
    1808   {
    1809     LispObj obj = *ref, header;
    1810     natural tag = fulltag_of(obj), header_tag, header_subtag;
    1811 
    1812     if ((tag == fulltag_misc) &&
    1813         (((BytePtr)ptr_from_lispobj(obj)) > low) &&
    1814         (((BytePtr)ptr_from_lispobj(obj)) < high)) {
    1815       header = deref(obj, 0);
    1816       if (header == forward_marker) { /* already copied */
    1817         *ref = (untag(deref(obj,1)) + tag);
     1810    loc = *locaddr,
     1811    *headerP;
     1812  opcode
     1813    *p,
     1814    insn;
     1815  natural
     1816    tag = fulltag_of(loc);
     1817
     1818  if (((BytePtr)ptr_from_lispobj(loc) > low) &&
     1819      ((BytePtr)ptr_from_lispobj(loc) < high)) {
     1820
     1821    headerP = (LispObj *)ptr_from_lispobj(untag(loc));
     1822    switch (tag) {
     1823    case fulltag_even_fixnum:
     1824    case fulltag_odd_fixnum:
     1825#ifdef PPC64
     1826    case fulltag_cons:
     1827    case fulltag_misc:
     1828#endif
     1829      if (*headerP == forward_marker) {
     1830        *locaddr = (headerP[1]+tag);
    18181831      } else {
    1819         header_tag = fulltag_of(header);
    1820         if (immheader_tag_p(header_tag)) {
    1821           header_subtag = header_subtag(header);
    1822           if (((header_subtag == subtag_code_vector) && (what_to_copy & COPY_CODE)) ||
    1823               ((what_to_copy & COPY_STRINGS) &&
    1824                ((header_subtag == subtag_simple_base_string)))) {
    1825             *ref = purify_object(obj, dest);
    1826           }
    1827         }
    1828       }
    1829     }
    1830   }
    1831 
    1832   void
    1833     purify_locref(LispObj *locaddr, BytePtr low, BytePtr high, area *to, int what)
    1834   {
    1835 #ifdef PPC
    1836     LispObj
    1837       loc = *locaddr,
    1838       *headerP;
    1839     opcode
    1840       *p,
    1841       insn;
    1842     natural
    1843       tag = fulltag_of(loc);
    1844 
    1845     if (((BytePtr)ptr_from_lispobj(loc) > low) &&
    1846 
    1847         ((BytePtr)ptr_from_lispobj(loc) < high)) {
    1848 
    1849       headerP = (LispObj *)ptr_from_lispobj(untag(loc));
    1850       switch (tag) {
    1851       case fulltag_even_fixnum:
    1852       case fulltag_odd_fixnum:
     1832        /* Grovel backwards until the header's found; copy
     1833           the code vector to to space, then treat it as if it
     1834           hasn't already been copied. */
     1835        p = (opcode *)headerP;
     1836        do {
     1837          p -= 2;
     1838          tag += 8;
     1839          insn = *p;
    18531840#ifdef PPC64
    1854       case fulltag_cons:
    1855       case fulltag_misc:
    1856 #endif
    1857         if (*headerP == forward_marker) {
    1858           *locaddr = (headerP[1]+tag);
    1859         } else {
    1860           /* Grovel backwards until the header's found; copy
    1861              the code vector to to space, then treat it as if it
    1862              hasn't already been copied. */
    1863           p = (opcode *)headerP;
    1864           do {
    1865             p -= 2;
    1866             tag += 8;
    1867             insn = *p;
    1868 #ifdef PPC64
    1869           } while (insn != PPC64_CODE_VECTOR_PREFIX);
    1870           headerP = ((LispObj*)p)-1;
    1871           *locaddr = purify_displaced_object(((LispObj)headerP), to, tag);
     1841        } while (insn != PPC64_CODE_VECTOR_PREFIX);
     1842        headerP = ((LispObj*)p)-1;
     1843        *locaddr = purify_displaced_object(((LispObj)headerP), to, tag);
    18721844#else
    1873         } while ((insn & code_header_mask) != subtag_code_vector);
    1874         *locaddr = purify_displaced_object(ptr_to_lispobj(p), to, tag);
    1875 #endif
    1876       }
    1877       break;
     1845      } while ((insn & code_header_mask) != subtag_code_vector);
     1846      *locaddr = purify_displaced_object(ptr_to_lispobj(p), to, tag);
     1847#endif
     1848    }
     1849    break;
    18781850
    18791851#ifndef PPC64
    1880     case fulltag_misc:
    1881       copy_ivector_reference(locaddr, low, high, to, what);
    1882       break;
    1883 #endif
    1884     }
    1885   }
    1886 #endif
    1887 }
    1888 
    1889 void
    1890 purify_range(LispObj *start, LispObj *end, BytePtr low, BytePtr high, area *to, int what)
     1852  case fulltag_misc:
     1853    copy_ivector_reference(locaddr, low, high, to);
     1854    break;
     1855#endif
     1856  }
     1857}
     1858#endif
     1859}
     1860
     1861void
     1862purify_range(LispObj *start, LispObj *end, BytePtr low, BytePtr high, area *to)
    18911863{
    18921864  LispObj header;
     
    19031875      } else {
    19041876        if (!nodeheader_tag_p(tag)) {
    1905           copy_ivector_reference(start, low, high, to, what);
     1877          copy_ivector_reference(start, low, high, to);
    19061878        }
    19071879        start++;
    1908         copy_ivector_reference(start, low, high, to, what);
     1880        copy_ivector_reference(start, low, high, to);
    19091881        start++;
    19101882      }
     
    19151887/* Purify references from tstack areas */
    19161888void
    1917 purify_tstack_area(area *a, BytePtr low, BytePtr high, area *to, int what)
     1889purify_tstack_area(area *a, BytePtr low, BytePtr high, area *to)
    19181890{
    19191891  LispObj
     
    19301902    end = ((next >= start) && (next < limit)) ? next : limit;
    19311903    if (current[1] == 0) {
    1932       purify_range(current+2, end, low, high, to, what);
     1904      purify_range(current+2, end, low, high, to);
    19331905    }
    19341906  }
     
    19371909/* Purify a vstack area */
    19381910void
    1939 purify_vstack_area(area *a, BytePtr low, BytePtr high, area *to, int what)
     1911purify_vstack_area(area *a, BytePtr low, BytePtr high, area *to)
    19401912{
    19411913  LispObj
     
    19441916
    19451917  if (((natural)p) & sizeof(natural)) {
    1946     copy_ivector_reference(p, low, high, to, what);
     1918    copy_ivector_reference(p, low, high, to);
    19471919    p++;
    19481920  }
    1949   purify_range(p, q, low, high, to, what);
    1950 }
    1951 
    1952 #ifdef PPC
    1953 void
    1954 purify_cstack_area(area *a, BytePtr low, BytePtr high, area *to, int what)
     1921  purify_range(p, q, low, high, to);
     1922}
     1923
     1924
     1925void
     1926purify_cstack_area(area *a, BytePtr low, BytePtr high, area *to)
    19551927{
    19561928  BytePtr
     
    19651937        (((((lisp_frame *)current)->savefn) == 0) ||
    19661938         (fulltag_of(((lisp_frame *)current)->savefn) == fulltag_misc))) {
    1967       purify_locref(&((lisp_frame *) current)->savelr, low, high, to, what);
     1939      purify_locref(&((lisp_frame *) current)->savelr, low, high, to);
    19681940    } else {
    19691941      /* Clear low bits of "next", just in case */
     
    19721944  }
    19731945}
    1974 #endif
    1975 
    1976 void
    1977 purify_xp(ExceptionInformation *xp, BytePtr low, BytePtr high, area *to, int what)
     1946
     1947void
     1948purify_xp(ExceptionInformation *xp, BytePtr low, BytePtr high, area *to)
    19781949{
    19791950  unsigned long *regs = (unsigned long *) xpGPRvector(xp);
    19801951
    1981 #ifdef PPC
    19821952  int r;
    19831953
     
    19871957
    19881958  for (r = fn; r < 32; r++) {
    1989     copy_ivector_reference((LispObj*) (&(regs[r])), low, high, to, what);
     1959    copy_ivector_reference((LispObj*) (&(regs[r])), low, high, to);
    19901960  };
    19911961
    1992   purify_locref((LispObj*) (&(regs[loc_pc])), low, high, to, what);
    1993 
    1994   purify_locref((LispObj*) (&(xpPC(xp))), low, high, to, what);
    1995   purify_locref((LispObj*) (&(xpLR(xp))), low, high, to, what);
    1996   purify_locref((LispObj*) (&(xpCTR(xp))), low, high, to, what);
    1997 #endif
    1998 
    1999 }
    2000 
    2001 void
    2002 purify_tcr_tlb(TCR *tcr, BytePtr low, BytePtr high, area *to, int what)
     1962  purify_locref((LispObj*) (&(regs[loc_pc])), low, high, to);
     1963
     1964  purify_locref((LispObj*) (&(xpPC(xp))), low, high, to);
     1965  purify_locref((LispObj*) (&(xpLR(xp))), low, high, to);
     1966  purify_locref((LispObj*) (&(xpCTR(xp))), low, high, to);
     1967}
     1968
     1969void
     1970purify_tcr_tlb(TCR *tcr, BytePtr low, BytePtr high, area *to)
    20031971{
    20041972  natural n = tcr->tlb_limit;
    20051973  LispObj *start = tcr->tlb_pointer, *end = (LispObj *) ((BytePtr)start+n);
    20061974
    2007   purify_range(start, end, low, high, to, what);
    2008 }
    2009 
    2010 void
    2011 purify_tcr_xframes(TCR *tcr, BytePtr low, BytePtr high, area *to, int what)
     1975  purify_range(start, end, low, high, to);
     1976}
     1977
     1978void
     1979purify_tcr_xframes(TCR *tcr, BytePtr low, BytePtr high, area *to)
    20121980{
    20131981  xframe_list *xframes;
     
    20161984  xp = tcr->gc_context;
    20171985  if (xp) {
    2018     purify_xp(xp, low, high, to, what);
     1986    purify_xp(xp, low, high, to);
    20191987  }
    20201988
    20211989  for (xframes = tcr->xframe; xframes; xframes = xframes->prev) {
    2022     purify_xp(xframes->curr, low, high, to, what);
    2023   }
    2024 }
    2025 
    2026 
    2027 void
    2028 purify_areas(BytePtr low, BytePtr high, area *target, int what)
     1990    purify_xp(xframes->curr, low, high, to);
     1991  }
     1992}
     1993
     1994void
     1995purify_gcable_ptrs(BytePtr low, BytePtr high, area *to)
     1996{
     1997  LispObj *prev = &(lisp_global(GCABLE_POINTERS)), next;
     1998
     1999  while ((*prev) != (LispObj)NULL) {
     2000    copy_ivector_reference(prev, low, high, to);
     2001    next = *prev;
     2002    prev = &(((xmacptr *)ptr_from_lispobj(untag(next)))->link);
     2003  }
     2004}
     2005
     2006
     2007void
     2008purify_areas(BytePtr low, BytePtr high, area *target)
    20292009{
    20302010  area *next_area;
     
    20342014    switch (code) {
    20352015    case AREA_TSTACK:
    2036       purify_tstack_area(next_area, low, high, target, what);
     2016      purify_tstack_area(next_area, low, high, target);
    20372017      break;
    20382018     
    20392019    case AREA_VSTACK:
    2040       purify_vstack_area(next_area, low, high, target, what);
     2020      purify_vstack_area(next_area, low, high, target);
    20412021      break;
    20422022     
    20432023    case AREA_CSTACK:
    2044 #ifdef PPC
    2045       purify_cstack_area(next_area, low, high, target, what);
    2046 #endif
     2024      purify_cstack_area(next_area, low, high, target);
    20472025      break;
    20482026     
    20492027    case AREA_STATIC:
    20502028    case AREA_DYNAMIC:
    2051       purify_range((LispObj *) next_area->low, (LispObj *) next_area->active, low, high, target, what);
     2029      purify_range((LispObj *) next_area->low, (LispObj *) next_area->active, low, high, target);
    20522030      break;
    20532031     
     
    20872065    lisp_global(IN_GC) = (1<<fixnumshift);
    20882066
    2089     /*
    2090       First, loop thru *all-packages* and purify the pnames of all
    2091       interned symbols.  Then walk every place that could reference
    2092       a heap-allocated object (all_areas, the xframe_list) and
    2093       purify code_vectors (and update the odd case of a shared
    2094       reference to a pname.)
    2095        
    2096       Make the new_pure_area executable, just in case.
    2097 
    2098       Caller will typically GC again (and that should recover quite a bit of
    2099       the dynamic heap.)
    2100       */
    2101 
    2102     {
    2103       lispsymbol *rawsym = (lispsymbol *)(&(nrs_ALL_PACKAGES));
    2104       LispObj pkg_list = rawsym->vcell, htab, obj;
    2105       package *p;
    2106       cons *c;
    2107       natural elements, i;
    2108 
    2109       while (fulltag_of(pkg_list) == fulltag_cons) {
    2110         c = (cons *) ptr_from_lispobj(untag(pkg_list));
    2111         p = (package *) ptr_from_lispobj(untag(c->car));
    2112         pkg_list = c->cdr;
    2113         c = (cons *) ptr_from_lispobj(untag(p->itab));
    2114         htab = c->car;
    2115         elements = header_element_count(header_of(htab));
    2116         for (i = 1; i<= elements; i++) {
    2117           obj = deref(htab,i);
    2118           if (fulltag_of(obj) == fulltag_misc) {
    2119             rawsym = (lispsymbol *) ptr_from_lispobj(untag(obj));
    2120             copy_ivector_reference(&(rawsym->pname), a->low, a->active, new_pure_area, COPY_STRINGS);
    2121           }
    2122         }
    2123         c = (cons *) ptr_from_lispobj(untag(p->etab));
    2124         htab = c->car;
    2125         elements = header_element_count(header_of(htab));
    2126         for (i = 1; i<= elements; i++) {
    2127           obj = deref(htab,i);
    2128           if (fulltag_of(obj) == fulltag_misc) {
    2129             rawsym = (lispsymbol *) ptr_from_lispobj(untag(obj));
    2130             copy_ivector_reference(&(rawsym->pname), a->low, a->active, new_pure_area, COPY_STRINGS);
    2131           }
    2132         }
    2133       }
    2134     }
    21352067   
    2136     purify_areas(a->low, a->active, new_pure_area, COPY_CODE);
     2068    purify_areas(a->low, a->active, new_pure_area);
    21372069   
    21382070    other_tcr = tcr;
    21392071    do {
    2140       purify_tcr_xframes(other_tcr, a->low, a->active, new_pure_area, COPY_CODE);
    2141       purify_tcr_tlb(other_tcr, a->low, a->active, new_pure_area, COPY_CODE);
     2072      purify_tcr_xframes(other_tcr, a->low, a->active, new_pure_area);
     2073      purify_tcr_tlb(other_tcr, a->low, a->active, new_pure_area);
    21422074      other_tcr = other_tcr->next;
    21432075    } while (other_tcr != tcr);
    21442076
     2077    purify_gcable_ptrs(a->low, a->active, new_pure_area);
    21452078
    21462079    {
     
    23602293}
    23612294
     2295void
     2296impurify_gcable_ptrs(LispObj low, LispObj high, signed_natural delta)
     2297{
     2298  LispObj *prev = &(lisp_global(GCABLE_POINTERS)), next;
     2299
     2300  while ((*prev) != (LispObj)NULL) {
     2301    impurify_noderef(prev, low, high, delta);
     2302    next = *prev;
     2303    prev = &(((xmacptr *)ptr_from_lispobj(untag(next)))->link);
     2304  }
     2305}
     2306
    23622307int
    23632308impurify(TCR *tcr, signed_natural param)
    23642309{
    2365   area *r = find_readonly_area();
     2310  area *r = readonly_area;
    23662311
    23672312  if (r) {
     
    23952340        other_tcr = other_tcr->next;
    23962341      } while (other_tcr != tcr);
     2342
     2343      impurify_gcable_ptrs(ptr_to_lispobj(ro_base), ptr_to_lispobj(ro_limit), delta);
    23972344      lisp_global(IN_GC) = 0;
    23982345    }
  • branches/working-0711-perf/ccl/lisp-kernel/ppc-macros.s

    r7624 r9701  
    4141
    4242ifdef([PPC64],[
    43         define([clrrri],[
    44         clrrdi $@
    45         ])       
    46         define([clrlri],[
    47         clrldi $@
    48         ])
    49         define([clrlri_],[
    50         clrldi. $@
    51         ])
    52         define([ldr],[
    53         ld $@
    54         ])
    55         define([ldrx],[
    56         ldx $@
    57         ])
    58         define([ldru],[
    59         ldu $@
    60         ])
    61         define([str],[
    62         std $@
    63         ])
    64         define([strx],[
    65         stdx $@
    66         ])
    67         define([stru],[
    68         stdu $@
    69         ])
    70         define([strux],[
    71         stdux $@
    72         ])     
    73         define([cmpr],[
    74         cmpd $@
    75         ])
    76         define([cmpri],[
    77         cmpdi $@
    78         ])
    79         define([cmplr],[
    80         cmpld $@
    81         ])
    82         define([cmplri],[
    83         cmpldi $@
    84         ])
    85         define([trlge],[
    86         tdlge $@
    87         ])
    88         define([trllt],[
    89         tdllt $@
    90         ])
    91         define([trlt],[
    92         tdlt $@
    93         ])
    94         define([trlle],[
    95         tdlle $@
    96         ])
    97         define([treqi],[
    98         tdeqi $@
    99         ])
    100         define([trnei],[
    101         tdnei $@
    102         ])
    103         define([trgti],[
    104         tdgti $@
    105         ])
    106         define([srari],[
    107         sradi $@
    108         ])
    109         define([srri],[
    110         srdi $@
    111         ])
    112         define([srr],[
    113         srd $@
    114         ])
    115         define([slri],[
    116         sldi $@
    117         ])
    118         define([lrarx],[
    119         ldarx $@
    120         ])
    121         define([strcx],[
    122         stdcx. $@
    123         ])
     43        define([clrrri],[clrrdi $@])       
     44        define([clrlri],[clrldi $@])
     45        define([clrlri_],[clrldi. $@])
     46        define([ldr],[ld $@])
     47        define([ldrx],[ldx $@])
     48        define([ldru],[ldu $@])
     49        define([str],[std $@])
     50        define([strx],[stdx $@])
     51        define([stru],[stdu $@])
     52        define([strux],[stdux $@])     
     53        define([cmpr],[cmpd $@])
     54        define([cmpri],[cmpdi $@])
     55        define([cmplr],[cmpld $@])
     56        define([cmplri],[cmpldi $@])
     57        define([trlge],[tdlge $@])
     58        define([trllt],[tdllt $@])
     59        define([trlt],[tdlt $@])
     60        define([trlle],[tdlle $@])
     61        define([treqi],[tdeqi $@])
     62        define([trnei],[tdnei $@])
     63        define([trgti],[tdgti $@])
     64        define([srari],[sradi $@])
     65        define([srri],[srdi $@])
     66        define([srr],[srd $@])
     67        define([slri],[sldi $@])
     68        define([lrarx],[ldarx $@])
     69        define([strcx],[stdcx. $@])
    12470        define([load_highbit],[
    125         lis $1,0x8000
    126         sldi $1,$1,32
     71        __(lis $1,0x8000)
     72        __(sldi $1,$1,32)
    12773        ])
    12874        define([extract_bit_shift_count],[
    129         clrldi $1,$2,64-bitmap_shift
     75        __(clrldi $1,$2,64-bitmap_shift)
    13076        ])
    13177        define([alloc_trap],[
    132         tdlt allocptr,allocbase
    133         ])
    134         define([mullr],[
    135         mulld $@
    136         ])
     78        __(tdlt allocptr,allocbase)
     79        ])
     80        define([mullr],[mulld $@])
    13781],[
    138         define([clrrri],[
    139         clrrwi $@
    140         ])
    141         define([clrlri],[
    142         clrlwi $@
    143         ])
    144         define([clrlri_],[
    145         clrlwi. $@
    146         ])
    147         define([ldr],[
    148         lwz $@
    149         ])
    150         define([ldrx],[
    151         lwzx $@
    152         ])
    153         define([ldru],[
    154         lwzu $@
    155         ])
    156         define([str],[
    157         stw $@
    158         ])
    159         define([strx],[
    160         stwx $@
    161         ])
    162         define([stru],[
    163         stwu $@
    164         ])
    165         define([strux],[
    166         stwux $@
    167         ])
    168         define([cmpr],[
    169         cmpw $@
    170         ])
    171         define([cmpri],[
    172         cmpwi $@
    173         ])
    174         define([cmplr],[
    175         cmplw $@
    176         ])
    177         define([cmplri],[
    178         cmplwi $@
    179         ])
    180         define([trlge],[
    181         twlge $@
    182         ])
    183         define([trllt],[
    184         twllt $@
    185         ])
    186         define([trlt],[
    187         twlt $@
    188         ])
    189         define([trlle],[
    190         twlle $@
    191         ])       
    192         define([treqi],[
    193         tweqi $@
    194         ])
    195         define([trnei],[
    196         twnei $@
    197         ])
    198         define([trgti],[
    199         twgti $@
    200         ])
    201         define([srari],[
    202         srawi $@
    203         ])
    204         define([srri],[
    205         srwi $@
    206         ])
    207         define([srr],[
    208         srw $@
    209         ])
    210         define([slri],[
    211         slwi $@
    212         ])
    213         define([lrarx],[
    214         lwarx $@
    215         ])
    216         define([strcx],[
    217         stwcx. $@
    218         ])
     82        define([clrrri],[clrrwi $@])
     83        define([clrlri],[clrlwi $@])
     84        define([clrlri_],[clrlwi. $@])
     85        define([ldr],[lwz $@])
     86        define([ldrx],[lwzx $@])
     87        define([ldru],[lwzu $@])
     88        define([str],[stw $@])
     89        define([strx],[stwx $@])
     90        define([stru],[stwu $@])
     91        define([strux],[stwux $@])
     92        define([cmpr],[cmpw $@])
     93        define([cmpri],[cmpwi $@])
     94        define([cmplr],[cmplw $@])
     95        define([cmplri],[cmplwi $@])
     96        define([trlge],[twlge $@])
     97        define([trllt],[twllt $@])
     98        define([trlt],[twlt $@])
     99        define([trlle],[twlle $@])       
     100        define([treqi],[tweqi $@])
     101        define([trnei],[twnei $@])
     102        define([trgti],[twgti $@])
     103        define([srari],[srawi $@])
     104        define([srri],[srwi $@])
     105        define([srr],[srw $@])
     106        define([slri],[slwi $@])
     107        define([lrarx],[lwarx $@])
     108        define([strcx],[stwcx. $@])
    219109        define([load_highbit],[
    220         lis $1,0x8000
     110        __(lis $1,0x8000)
    221111        ])
    222112        define([extract_bit_shift_count],[
    223         clrlwi $1,$2,32-bitmap_shift
     113        __(clrlwi $1,$2,32-bitmap_shift)
    224114        ])
    225115        define([alloc_trap],[
    226         twllt allocptr,allocbase
    227         ])
    228         define([mullr],[
    229         mullw $@
    230         ])
     116        __(twllt allocptr,allocbase)
     117        ])
     118        define([mullr],[mullw $@])
    231119])
    232120
    233121/* dnode_align(dest,src,delta) */
    234122        define([dnode_align],[
    235         la $1,($3+(dnode_size-1))($2)
    236         clrrri($1,$1,dnode_align_bits)
     123        __(la $1,($3+(dnode_size-1))($2))
     124        __(clrrri($1,$1,dnode_align_bits))
    237125])
    238126
    239127define([extract_fulltag],[
    240         clrlri($1,$2,nbits_in_word-ntagbits)
     128        __(clrlri($1,$2,nbits_in_word-ntagbits))
    241129        ])
    242130
    243131define([extract_lisptag],[
    244         clrlri($1,$2,nbits_in_word-nlisptagbits)
     132        __(clrlri($1,$2,nbits_in_word-nlisptagbits))
    245133        ])
    246134
    247135define([extract_lisptag_],[
    248         clrlri_($1,$2,nbits_in_word-nlisptagbits)
     136        __(clrlri_($1,$2,nbits_in_word-nlisptagbits))
    249137        ])
    250138
    251139define([extract_subtag],[
    252         lbz $1,misc_subtag_offset($2)])
     140        __(lbz $1,misc_subtag_offset($2))
     141        ])
    253142
    254143ifdef([PPC64],[
    255144define([extract_lowtag],[
    256         clrldi $1,$2,nbits_in_word-nlowtagbits
     145        __(clrldi $1,$2,nbits_in_word-nlowtagbits)
    257146])
    258147define([trap_unless_lowtag_equal],[
    259         clrldi $3,$1,nbits_in_word-nlowtagbits
    260         tdnei $3,$2
     148        __(clrldi $3,$1,nbits_in_word-nlowtagbits)
     149        __(tdnei $3,$2)
    261150])               
    262151        ])
    263152                               
    264153define([extract_lowbyte],[
    265         clrlri($1,$2,nbits_in_word-num_subtag_bits)
     154        __(clrlri($1,$2,nbits_in_word-num_subtag_bits))
    266155        ])
    267156
    268157define([extract_header],[
    269         ldr($1,misc_header_offset($2))])
     158        __(ldr($1,misc_header_offset($2)))
     159        ])
    270160
    271161
     
    273163define([extract_typecode],[
    274164        new_macro_labels()
    275         extract_fulltag($1,$2)
    276         cmpdi cr0,$1,fulltag_misc
    277         extract_lisptag($1,$1)
    278         bne cr0,macro_label(not_misc)
    279         extract_subtag($1,$2)
     165        __(extract_fulltag($1,$2))
     166        __(cmpdi cr0,$1,fulltag_misc)
     167        __(extract_lisptag($1,$1))
     168        __(bne cr0,macro_label(not_misc))
     169        __(extract_subtag($1,$2))
    280170macro_label(not_misc):
    281171])],[   
    282172define([extract_typecode],[
    283173        new_macro_labels()
    284         extract_lisptag($1,$2)
    285         cmpwi cr0,$1,tag_misc
    286         bne cr0,macro_label(not_misc)
    287         extract_subtag($1,$2)
     174        __(extract_lisptag($1,$2))
     175        __(cmpwi cr0,$1,tag_misc)
     176        __(bne cr0,macro_label(not_misc))
     177        __(extract_subtag($1,$2))
    288178macro_label(not_misc):
    289179])])
    290180
    291181define([box_fixnum],[
    292         slri($1,$2,fixnumshift)])
     182        __(slri($1,$2,fixnumshift))
     183        ])
    293184
    294185define([unbox_fixnum],[
    295         srari($1,$2,fixnumshift)])
     186        __(srari($1,$2,fixnumshift))
     187        ])
    296188
    297189define([loaddf],[
    298         lfd $1,dfloat.value($2)])
     190        __(lfd $1,dfloat.value($2))])
    299191       
    300192define([storedf],[
    301         stfd $1,dfloat.value($2)])
     193        __(stfd $1,dfloat.value($2))
     194        ])
    302195
    303196define([push],[
    304         stru($1,-node_size($2))])
     197        __(stru($1,-node_size($2)))
     198        ])
    305199       
    306200        /* Generally not a great idea. */
    307201define([pop],[
    308         ldr($1,0($2))
    309         la $2,node_size($2)])
     202        __(ldr($1,0($2)))
     203        __(la $2,node_size($2))
     204        ])
    310205       
    311206define([vpush],[
    312         push($1,vsp)])
     207        __(push($1,vsp))
     208        ])
    313209       
    314210define([vpop],[
    315         pop($1,vsp)])
     211        __(pop($1,vsp))
     212        ])
    316213       
    317214               
    318215define([unlink],[
    319         ldr($1,0($1))
     216        __(ldr($1,0($1)))
    320217 ])
    321218
    322219       
    323220define([set_nargs],[
    324         lwi(nargs,($1)<<fixnumshift)])
     221        __(lwi(nargs,($1)<<fixnumshift))
     222        ])
    325223       
    326224define([bitclr],[
    327         rlwinm $1,$2,0,0x1f&((31-($3))+1),0x1f&((31-($3))-1)])
     225        __(rlwinm $1,$2,0,0x1f&((31-($3))+1),0x1f&((31-($3))-1))
     226        ])
    328227       
    329228
    330229define([vref32],[
    331         lwz $1,misc_data_offset+(($3)<<2)($2)])
     230        __(lwz $1,misc_data_offset+(($3)<<2)($2))
     231        ])
    332232       
    333233define([vref16],[/* dest,src,n*/
    334         lhz $1,misc_data_offset+(($3)<<1)($2)])
     234        __(lhz $1,misc_data_offset+(($3)<<1)($2))
     235        ])
    335236       
    336237ifdef([PPC64],[
    337238        define([vref64],[
    338         ld $1,misc_data_offset+(($3)<<3)($2)])
     239        __(ld $1,misc_data_offset+(($3)<<3)($2))
     240        ])
    339241
    340242        define([vrefr],[
    341         vref64($1,$2,$3)])
     243        __(vref64($1,$2,$3))
     244        ])
    342245],[
    343246        define([vrefr],[
    344         vref32($1,$2,$3)])
     247        __(vref32($1,$2,$3))
     248        ])
    345249])
    346250       
    347251                       
    348252define([getvheader],[
    349         ldr($1,vector.header($2))])
     253        __(ldr($1,vector.header($2)))
     254        ])
    350255       
    351256        /* Size is unboxed element count */
    352257define([header_size],[
    353         srri($1,$2,num_subtag_bits)])
     258        __(srri($1,$2,num_subtag_bits))
     259        ])
    354260       
    355261        /* "Length" is fixnum element count */
    356262define([header_length],[
    357263ifdef([PPC64],[
    358         rldicr $1,$2,nbits_in_word-(num_subtag_bits-nfixnumtagbits),63-nfixnumtagbits
    359         clrldi $1,$1,(num_subtag_bits-nfixnumtagbits)
     264        __(rldicr $1,$2,nbits_in_word-(num_subtag_bits-nfixnumtagbits),63-nfixnumtagbits)
     265        __(clrldi $1,$1,(num_subtag_bits-nfixnumtagbits))
    360266        ],[               
    361         rlwinm $1,$2,nbits_in_word-(num_subtag_bits-nfixnumtagbits),(num_subtag_bits-nfixnumtagbits),31-nfixnumtagbits
     267        __(rlwinm $1,$2,nbits_in_word-(num_subtag_bits-nfixnumtagbits),(num_subtag_bits-nfixnumtagbits),31-nfixnumtagbits)
    362268        ])
    363269])       
     
    365271
    366272define([vector_size],[
    367         getvheader(ifelse($3.[],$1,$3),$2)
    368         header_size($1,ifelse($3.[],$1,$3))])
     273        __(getvheader(ifelse($3.[],$1,$3),$2))
     274        __(header_size($1,ifelse($3.[],$1,$3)))
     275        ])
    369276       
    370277define([vector_length],[
    371         getvheader($3,$2)
    372         header_length($1,$3)])
     278        __(getvheader($3,$2))
     279        __(header_length($1,$3))
     280        ])
    373281
    374282       
    375283define([ref_global],[
    376         ldr($1,lisp_globals.$2(0))
     284        __(ldr($1,lisp_globals.$2(0)))
    377285])
    378286
    379287define([set_global],[
    380         str($1,lisp_globals.$2(0))
     288        __(str($1,lisp_globals.$2(0)))
    381289])
    382290
    383291define([ref_nrs_value],[
    384         ldr($1,((nrs.$2)+(symbol.vcell))(0))
     292        __(ldr($1,((nrs.$2)+(symbol.vcell))(0)))
    385293])
    386294       
    387295define([set_nrs_value],[
    388         str($1,((nrs.$2)+(symbol.vcell))(0))
     296        __(str($1,((nrs.$2)+(symbol.vcell))(0)))
    389297])
    390298
    391299define([extract_unsigned_byte_bits],[
    392300ifdef([PPC64],[
    393         rldicr $1,$2,64-fixnumshift,63-$3
     301        __(rldicr $1,$2,64-fixnumshift,63-$3)
    394302],[               
    395         rlwinm $1,$2,0,32-fixnumshift,31-($3+fixnumshift)
     303        __(rlwinm $1,$2,0,32-fixnumshift,31-($3+fixnumshift))
    396304])       
    397305])
     
    399307define([extract_unsigned_byte_bits_],[
    400308ifdef([PPC64],[
    401         rldicr. $1,$2,64-fixnumshift,63-$3
     309        __(rldicr. $1,$2,64-fixnumshift,63-$3)
    402310],[               
    403         rlwinm. $1,$2,0,32-fixnumshift,31-($3+fixnumshift)
     311        __(rlwinm. $1,$2,0,32-fixnumshift,31-($3+fixnumshift))
    404312])       
    405313])
     
    408316define([vpop_argregs_nz],[
    409317        new_macro_labels()
    410         cmplri(cr1,nargs,node_size*2)
    411         vpop(arg_z)
    412         blt cr1,macro_label(l0)
    413         vpop(arg_y)
    414         bne cr1,macro_label(l0)
    415         vpop(arg_x)
     318        __(cmplri(cr1,nargs,node_size*2))
     319        __(vpop(arg_z))
     320        __(blt cr1,macro_label(l0))
     321        __(vpop(arg_y))
     322        __(bne cr1,macro_label(l0))
     323        __(vpop(arg_x))
    416324macro_label(l0):])
    417325
     
    420328define([vpush_argregs],[
    421329        new_macro_labels()
    422         cmplri(cr0,nargs,0)
    423         cmplri(cr1,nargs,node_size*2)
    424         beq cr0,macro_label(done)
    425         blt cr1,macro_label(z)
    426         beq cr1,macro_label(yz)
    427         vpush(arg_x)
     330        __(cmplri(cr0,nargs,0))
     331        __(cmplri(cr1,nargs,node_size*2))
     332        __(beq cr0,macro_label(done))
     333        __(blt cr1,macro_label(z))
     334        __(beq cr1,macro_label(yz))
     335        __(vpush(arg_x))
    428336macro_label(yz):
    429         vpush(arg_y)
     337        __(vpush(arg_y))
    430338macro_label(z):
    431         vpush(arg_z)
     339        __(vpush(arg_z))
    432340macro_label(done):
    433341])
    434342
    435343define([create_lisp_frame],[
    436         stru(sp,-lisp_frame.size(sp))
     344        __(stru(sp,-lisp_frame.size(sp)))
    437345])
    438346
     
    440348define([build_lisp_frame],[
    441349        create_lisp_frame()
    442         str(ifelse($1,[],fn,$1),lisp_frame.savefn(sp))
    443         str(ifelse($2,[],loc_pc,$2),lisp_frame.savelr(sp))
    444         str(ifelse($3,[],vsp,$3),lisp_frame.savevsp(sp))
     350        __(str(ifelse($1,[],fn,$1),lisp_frame.savefn(sp)))
     351        __(str(ifelse($2,[],loc_pc,$2),lisp_frame.savelr(sp)))
     352        __(str(ifelse($3,[],vsp,$3),lisp_frame.savevsp(sp)))
    445353])
    446354
    447355               
    448356define([discard_lisp_frame],[
    449         la sp,lisp_frame.size(sp)])
     357        __(la sp,lisp_frame.size(sp))
     358        ])
    450359       
    451360       
    452361define([_car],[
    453         ldr($1,cons.car($2))
     362        __(ldr($1,cons.car($2)))
    454363])
    455364       
    456365define([_cdr],[
    457         ldr($1,cons.cdr($2))])
     366        __(ldr($1,cons.cdr($2)))
     367        ])
    458368       
    459369define([_rplaca],[
    460         str($2,cons.car($1))])
     370        __(str($2,cons.car($1)))
     371        ])
    461372       
    462373define([_rplacd],[
    463         str($2,cons.cdr($1))])
     374        __(str($2,cons.cdr($1)))
     375        ])
    464376
    465377define([vpush_saveregs],[
    466         vpush(save7)
    467         vpush(save6)
    468         vpush(save5)
    469         vpush(save4)
    470         vpush(save3)
    471         vpush(save2)
    472         vpush(save1)
    473         vpush(save0)])
     378        __(vpush(save7))
     379        __(vpush(save6))
     380        __(vpush(save5))
     381        __(vpush(save4))
     382        __(vpush(save3))
     383        __(vpush(save2))
     384        __(vpush(save1))
     385        __(vpush(save0))
     386        ])
    474387       
    475388define([restore_saveregs],[
    476         ldr(save0,node_size*0($1))
    477         ldr(save1,node_size*1($1))
    478         ldr(save2,node_size*2($1))
    479         ldr(save3,node_size*3($1))
    480         ldr(save4,node_size*4($1))
    481         ldr(save5,node_size*5($1))
    482         ldr(save6,node_size*6($1))
    483         ldr(save7,node_size*7($1))
     389        __(ldr(save0,node_size*0($1)))
     390        __(ldr(save1,node_size*1($1)))
     391        __(ldr(save2,node_size*2($1)))
     392        __(ldr(save3,node_size*3($1)))
     393        __(ldr(save4,node_size*4($1)))
     394        __(ldr(save5,node_size*5($1)))
     395        __(ldr(save6,node_size*6($1)))
     396        __(ldr(save7,node_size*7($1)))
    484397])
    485398
    486399define([vpop_saveregs],[
    487         restore_saveregs(vsp)
    488         la vsp,node_size*8(vsp)
     400        __(restore_saveregs(vsp))
     401        __(la vsp,node_size*8(vsp))
    489402])
    490403
    491404define([trap_unless_lisptag_equal],[
    492         extract_lisptag($3,$1)
    493         trnei($3,$2)
     405        __(extract_lisptag($3,$1))
     406        __(trnei($3,$2))
    494407])
    495408
     
    497410define([trap_unless_list],[
    498411        new_macro_labels()
    499         cmpdi ifelse($3,$3,cr0),$1,nil_value
    500         extract_fulltag($2,$1)
    501         beq ifelse($3,$3,cr0),macro_label(is_list)
    502         tdnei $2,fulltag_cons
     412        __(cmpdi ifelse($3,$3,cr0),$1,nil_value)
     413        __(extract_fulltag($2,$1))
     414        __(beq ifelse($3,$3,cr0),macro_label(is_list))
     415        __(tdnei $2,fulltag_cons)
    503416macro_label(is_list):   
    504417
    505418])],[   
    506419define([trap_unless_list],[
    507         trap_unless_lisptag_equal($1,tag_list,$2)
     420        __(trap_unless_lisptag_equal($1,tag_list,$2))
    508421])
    509422])
    510423
    511424define([trap_unless_fulltag_equal],[
    512         extract_fulltag($3,$1)
    513         trnei($3,$2)
     425        __(extract_fulltag($3,$1))
     426        __(trnei($3,$2))
    514427])
    515428       
    516429define([trap_unless_typecode_equal],[
    517         extract_typecode($3,$1)
    518         trnei($3,$2)
     430        __(extract_typecode($3,$1))
     431        __(trnei($3,$2))
    519432])
    520433       
    521434/* "jump" to the code-vector of the function in nfn. */
    522435define([jump_nfn],[
    523         ldr(temp0,_function.codevector(nfn))
    524         mtctr temp0
    525         bctr
     436        __(ldr(temp0,_function.codevector(nfn)))
     437        __(mtctr temp0)
     438        __(bctr)
    526439])
    527440
    528441/* "call the code-vector of the function in nfn. */
    529442define([call_nfn],[
    530         ldr(temp0,_function.codevector(nfn))
    531         mtctr temp0
    532         bctrl
     443        __(ldr(temp0,_function.codevector(nfn)))
     444        __(mtctr temp0)
     445        __(bctrl)
    533446])
    534447       
     
    536449/* "jump" to the function in fnames function cell. */
    537450define([jump_fname],[
    538         ldr(nfn,symbol.fcell(fname))
    539         jump_nfn()
     451        __(ldr(nfn,symbol.fcell(fname)))
     452        __(jump_nfn())
    540453])
    541454
    542455/* call the function in fnames function cell. */
    543456define([call_fname],[
    544         ldr(nfn,symbol.fcell(fname))
    545         call_nfn()
     457        __(ldr(nfn,symbol.fcell(fname)))
     458        __(call_nfn())
    546459])
    547460
    548461define([do_funcall],[
    549462        new_macro_labels()
    550         extract_fulltag(imm0,temp0)
    551         cmpri(imm0,fulltag_misc)
    552         mr nfn,temp0
    553         bne- macro_label(bad)
    554         extract_subtag(imm0,temp0)
    555         cmpri(imm0,subtag_function)
    556         cmpri(cr1,imm0,subtag_symbol)
    557         bne cr0,macro_label(_sym)
    558         jump_nfn()
     463        __(extract_fulltag(imm0,temp0))
     464        __(cmpri(imm0,fulltag_misc))
     465        __(mr nfn,temp0)
     466        __(bne- macro_label(bad))
     467        __(extract_subtag(imm0,temp0))
     468        __(cmpri(imm0,subtag_function))
     469        __(cmpri(cr1,imm0,subtag_symbol))
     470        __(bne cr0,macro_label(_sym))
     471        __(jump_nfn())
    559472macro_label(_sym):             
    560         mr fname,temp0
    561         bne cr1,macro_label(bad)
    562         jump_fname()
     473        __(mr fname,temp0)
     474        __(bne cr1,macro_label(bad))
     475        __(jump_fname())
    563476macro_label(bad):
    564         uuo_interr(error_cant_call,temp0)
     477        __(uuo_interr(error_cant_call,temp0))
    565478])     
    566479
    567480define([mkcatch],[
    568         mflr loc_pc
    569         ldr(imm0,tcr.catch_top(rcontext))
    570         lwz imm1,0(loc_pc) /* a forward branch to the catch/unwind cleanup */
    571         rlwinm imm1,imm1,0,6,29 /* extract LI */
    572         add loc_pc,loc_pc,imm1
    573         build_lisp_frame(fn,loc_pc,vsp)
    574         sub loc_pc,loc_pc,imm1
    575         la loc_pc,4(loc_pc)     /* skip over the forward branch */
    576         mtlr loc_pc
    577         lwi(imm4,(catch_frame.element_count<<num_subtag_bits)|subtag_catch_frame)
    578         ldr(imm3,tcr.xframe(rcontext))
    579         ldr(imm1,tcr.db_link(rcontext))
    580         TSP_Alloc_Fixed_Unboxed(catch_frame.size)
    581         la nargs,tsp_frame.data_offset+fulltag_misc(tsp)
    582         str(imm4,catch_frame.header(nargs))
    583         str(arg_z,catch_frame.catch_tag(nargs))
    584         str(imm0,catch_frame.link(nargs))
    585         str(imm2,catch_frame.mvflag(nargs))
    586         str(sp,catch_frame.csp(nargs))
    587         str(imm1,catch_frame.db_link(nargs))
    588         str(first_nvr,catch_frame.regs+0*node_size(nargs))
    589         str(second_nvr,catch_frame.regs+1*node_size(nargs))
    590         str(third_nvr,catch_frame.regs+2*node_size(nargs))
    591         str(fourth_nvr,catch_frame.regs+3*node_size(nargs))
    592         str(fifth_nvr,catch_frame.regs+4*node_size(nargs))
    593         str(sixth_nvr,catch_frame.regs+5*node_size(nargs))
    594         str(seventh_nvr,catch_frame.regs+6*node_size(nargs))
    595         str(eighth_nvr,catch_frame.regs+7*node_size(nargs))
    596         str(imm3,catch_frame.xframe(nargs))
    597         str(rzero,catch_frame.tsp_segment(nargs))
    598         Set_TSP_Frame_Boxed()
    599         str(nargs,tcr.catch_top(rcontext))
    600         li nargs,0
     481        __(mflr loc_pc)
     482        __(ldr(imm0,tcr.catch_top(rcontext)))
     483        __(lwz imm1,0(loc_pc)) /* a forward branch to the catch/unwind cleanup */
     484        __(rlwinm imm1,imm1,0,6,29)     /* extract LI */
     485        __(add loc_pc,loc_pc,imm1)
     486        __(build_lisp_frame(fn,loc_pc,vsp))
     487        __(sub loc_pc,loc_pc,imm1)
     488        __(la loc_pc,4(loc_pc)) /* skip over the forward branch */
     489        __(mtlr loc_pc)
     490        __(lwi(imm4,(catch_frame.element_count<<num_subtag_bits)|subtag_catch_frame))
     491        __(ldr(imm3,tcr.xframe(rcontext)))
     492        __(ldr(imm1,tcr.db_link(rcontext)))
     493        __(TSP_Alloc_Fixed_Unboxed(catch_frame.size))
     494        __(la nargs,tsp_frame.data_offset+fulltag_misc(tsp))
     495        __(str(imm4,catch_frame.header(nargs)))
     496        __(str(arg_z,catch_frame.catch_tag(nargs)))
     497        __(str(imm0,catch_frame.link(nargs)))
     498        __(str(imm2,catch_frame.mvflag(nargs)))
     499        __(str(sp,catch_frame.csp(nargs)))
     500        __(str(imm1,catch_frame.db_link(nargs)))
     501        __(str(first_nvr,catch_frame.regs+0*node_size(nargs)))
     502        __(str(second_nvr,catch_frame.regs+1*node_size(nargs)))
     503        __(str(third_nvr,catch_frame.regs+2*node_size(nargs)))
     504        __(str(fourth_nvr,catch_frame.regs+3*node_size(nargs)))
     505        __(str(fifth_nvr,catch_frame.regs+4*node_size(nargs)))
     506        __(str(sixth_nvr,catch_frame.regs+5*node_size(nargs)))
     507        __(str(seventh_nvr,catch_frame.regs+6*node_size(nargs)))
     508        __(str(eighth_nvr,catch_frame.regs+7*node_size(nargs)))
     509        __(str(imm3,catch_frame.xframe(nargs)))
     510        __(str(rzero,catch_frame.tsp_segment(nargs)))
     511        __(Set_TSP_Frame_Boxed())
     512        __(str(nargs,tcr.catch_top(rcontext)))
     513        __(li nargs,0)
    601514
    602515])     
    603516
    604517define([restore_catch_nvrs],[
    605         ldr(first_nvr,catch_frame.regs+(node_size*0)($1))
    606         ldr(second_nvr,catch_frame.regs+(node_size*1)($1))
    607         ldr(third_nvr,catch_frame.regs+(node_size*2)($1))
    608         ldr(fourth_nvr,catch_frame.regs+(node_size*3)($1))
    609         ldr(fifth_nvr,catch_frame.regs+(node_size*4)($1))
    610         ldr(sixth_nvr,catch_frame.regs+(node_size*5)($1))
    611         ldr(seventh_nvr,catch_frame.regs+(node_size*6)($1))
    612         ldr(eighth_nvr,catch_frame.regs+(node_size*7)($1))
     518        __(ldr(first_nvr,catch_frame.regs+(node_size*0)($1)))
     519        __(ldr(second_nvr,catch_frame.regs+(node_size*1)($1)))
     520        __(ldr(third_nvr,catch_frame.regs+(node_size*2)($1)))
     521        __(ldr(fourth_nvr,catch_frame.regs+(node_size*3)($1)))
     522        __(ldr(fifth_nvr,catch_frame.regs+(node_size*4)($1)))
     523        __(ldr(sixth_nvr,catch_frame.regs+(node_size*5)($1)))
     524        __(ldr(seventh_nvr,catch_frame.regs+(node_size*6)($1)))
     525        __(ldr(eighth_nvr,catch_frame.regs+(node_size*7)($1)))
    613526])               
    614527
    615528define([DCBZL],[
    616         .long (31<<26)+(1<<21)+($1<<16)+($2<<11)+(1014<<1)
     529        __(.long (31<<26)+(1<<21)+($1<<16)+($2<<11)+(1014<<1))
    617530])
    618531       
    619532define([check_stack_alignment],[
    620533        new_macro_labels()
    621         andi. $1,sp,STACK_ALIGN_MASK
    622         beq+ macro_label(stack_ok)
    623         .long 0
     534        __(andi. $1,sp,STACK_ALIGN_MASK)
     535        __(beq+ macro_label(stack_ok))
     536        __(.long 0)
    624537macro_label(stack_ok):
    625538])
     
    628541
    629542define([clear_alloc_tag],[
    630         clrrri(allocptr,allocptr,ntagbits)
     543        __(clrrri(allocptr,allocptr,ntagbits))
    631544])
    632545
     
    650563       
    651564define([Cons],[
    652         la allocptr,(-cons.size+fulltag_cons)(allocptr)
    653         alloc_trap()
    654         str($3,cons.cdr(allocptr))
    655         str($2,cons.car(allocptr))
    656         mr $1,allocptr
    657         clear_alloc_tag()
     565        __(la allocptr,(-cons.size+fulltag_cons)(allocptr))
     566        __(alloc_trap())
     567        __(str($3,cons.cdr(allocptr)))
     568        __(str($2,cons.car(allocptr)))
     569        __(mr $1,allocptr)
     570        __(clear_alloc_tag())
    658571])
    659572
     
    685598
    686599define([Misc_Alloc],[
    687         la $3,-fulltag_misc($3)
    688         sub allocptr,allocptr,$3
    689         alloc_trap()
    690         str($2,misc_header_offset(allocptr))
    691         mr $1,allocptr
    692         clear_alloc_tag()
     600        __(la $3,-fulltag_misc($3))
     601        __(sub allocptr,allocptr,$3)
     602        __(alloc_trap())
     603        __(str($2,misc_header_offset(allocptr)))
     604        __(mr $1,allocptr)
     605        __(clear_alloc_tag())
    693606])
    694607
    695608/*  Parameters $1, $2 as above; $3 = physical size constant. */
    696609define([Misc_Alloc_Fixed],[
    697         la allocptr,(-$3)+fulltag_misc(allocptr)
    698         alloc_trap()
    699         str($2,misc_header_offset(allocptr))
    700         mr $1,allocptr
    701         clear_alloc_tag()
     610        __(la allocptr,(-$3)+fulltag_misc(allocptr))
     611        __(alloc_trap())
     612        __(str($2,misc_header_offset(allocptr)))
     613        __(mr $1,allocptr)
     614        __(clear_alloc_tag())
    702615])
    703616
     
    726639
    727640define([Set_TSP_Frame_Unboxed],[
    728         str(tsp,tsp_frame.type(tsp))
     641        __(str(tsp,tsp_frame.type(tsp)))
    729642])
    730643
    731644define([Set_TSP_Frame_Boxed],[
    732         str(rzero,tsp_frame.type(tsp))
     645        __(str(rzero,tsp_frame.type(tsp)))
    733646])
    734647               
     
    737650
    738651define([TSP_Alloc_Fixed_Unboxed],[
    739         stru(tsp,-($1+tsp_frame.data_offset)(tsp))
    740         Set_TSP_Frame_Unboxed()
     652        __(stru(tsp,-($1+tsp_frame.data_offset)(tsp)))
     653        __(Set_TSP_Frame_Unboxed())
    741654])
    742655
    743656define([TSP_Alloc_Fixed_Unboxed_Zeroed],[
    744         TSP_Alloc_Fixed_Unboxed($1)
    745         zero_doublewords tsp,tsp_frame.fixed_overhead,$1
     657        __(TSP_Alloc_Fixed_Unboxed($1))
     658        __(zero_doublewords tsp,tsp_frame.fixed_overhead,$1)
    746659])
    747660
    748661define([TSP_Alloc_Fixed_Boxed],[
    749         TSP_Alloc_Fixed_Unboxed_Zeroed($1)
    750         Set_TSP_Frame_Boxed()
     662        __(TSP_Alloc_Fixed_Unboxed_Zeroed($1))
     663        __(Set_TSP_Frame_Boxed())
    751664])
    752665
     
    765678/* Handle the general case, where the frame might be empty */
    766679define([Zero_TSP_Frame],[
    767         new_macro_labels()
    768         la $1,tsp_frame.size-8(tsp)
    769         ldr($2,tsp_frame.backlink(tsp))
    770         la $2,-8($2)
    771         b macro_label(zero_tsp_test)
     680        __(new_macro_labels())
     681        __(la $1,tsp_frame.size-8(tsp))
     682        __(ldr($2,tsp_frame.backlink(tsp)))
     683        __(la $2,-8($2))
     684        __(b macro_label(zero_tsp_test))
    772685macro_label(zero_tsp_loop):
    773         stfdu fp_zero,8($1)
     686        __(stfdu fp_zero,8($1))
    774687macro_label(zero_tsp_test):     
    775         cmpr(ifelse($3,[],[cr0],$3),$1,$2)
    776         bne ifelse($3,[],[cr0],$3),macro_label(zero_tsp_loop)
     688        __(cmpr(ifelse($3,[],[cr0],$3),$1,$2))
     689        __(bne ifelse($3,[],[cr0],$3),macro_label(zero_tsp_loop))
    777690])
    778691
     
    780693define([Zero_TSP_Frame_nz],[
    781694        new_macro_labels()
    782         la $1,tsp_frame.size-8(tsp)
    783         ldr($2,tsp_frame.backlink(tsp))
    784         la $2,-8($2)
     695        __(la $1,tsp_frame.size-8(tsp))
     696        __(ldr($2,tsp_frame.backlink(tsp)))
     697        __(la $2,-8($2))
    785698macro_label(zero_tsp_loop):
    786         stfdu fp_zero,8($1)
    787         cmpr(ifelse($3,[],[cr0],$3),$1,$2)
    788         bne ifelse($3,[],[cr0],$3),macro_label(zero_tsp_loop)
     699        __(stfdu fp_zero,8($1))
     700        __(cmpr(ifelse($3,[],[cr0],$3),$1,$2))
     701        __(bne ifelse($3,[],[cr0],$3),macro_label(zero_tsp_loop))
    789702])
    790703       
     
    792705/* to negated size. */
    793706define([TSP_Alloc_Var_Unboxed],[
    794         neg ifelse($2,[],$1,$2),$1
    795         strux(tsp,tsp,ifelse($2,[],$1,$2))
    796         Set_TSP_Frame_Unboxed()
     707        __(neg ifelse($2,[],$1,$2),$1)
     708        __(strux(tsp,tsp,ifelse($2,[],$1,$2)))
     709        __(Set_TSP_Frame_Unboxed())
    797710])
    798711
    799712define([TSP_Alloc_Var_Boxed],[
    800         TSP_Alloc_Var_Unboxed($1)
    801         Zero_TSP_Frame($1,$2)
    802         Set_TSP_Frame_Boxed()
     713        __(TSP_Alloc_Var_Unboxed($1))
     714        __(Zero_TSP_Frame($1,$2))
     715        __(Set_TSP_Frame_Boxed())
    803716])             
    804717
    805718
    806719define([TSP_Alloc_Var_Boxed_nz],[
    807         TSP_Alloc_Var_Unboxed($1)
    808         Zero_TSP_Frame_nz($1,$2)
    809         Set_TSP_Frame_Boxed()
     720        __(TSP_Alloc_Var_Unboxed($1))
     721        __(Zero_TSP_Frame_nz($1,$2))
     722        __(Set_TSP_Frame_Boxed())
    810723])             
    811724
    812725define([check_pending_interrupt],[
    813726        new_macro_labels()
    814         ldr(nargs,tcr.tlb_pointer(rcontext))
    815         ldr(nargs,INTERRUPT_LEVEL_BINDING_INDEX(nargs))
    816         cmpri(ifelse($1,[],[cr0],$1),nargs,0)
    817         blt ifelse($1,[],[cr0],$1),macro_label(done)
    818         bgt ifelse($1,[],[cr0],$1),macro_label(trap)
    819         ldr(nargs,tcr.interrupt_pending(rcontext))
     727        __(ldr(nargs,tcr.tlb_pointer(rcontext)))
     728        __(ldr(nargs,INTERRUPT_LEVEL_BINDING_INDEX(nargs)))
     729        __(cmpri(ifelse($1,[],[cr0],$1),nargs,0))
     730        __(blt ifelse($1,[],[cr0],$1),macro_label(done))
     731        __(bgt ifelse($1,[],[cr0],$1),macro_label(trap))
     732        __(ldr(nargs,tcr.interrupt_pending(rcontext)))
    820733macro_label(trap):
    821         trgti(nargs,0)
     734        __(trgti(nargs,0))
    822735macro_label(done):
    823736])
     
    827740
    828741define([suspend_now],[
    829         uuo_interr(error_propagate_suspend,rzero)
    830 ])
     742        __(uuo_interr(error_propagate_suspend,rzero))
     743])
  • branches/working-0711-perf/ccl/lisp-kernel/thread_manager.c

    r9337 r9701  
    5555raise_thread_interrupt(TCR *target)
    5656{
     57  pthread_t thread = (pthread_t)target->osid;
    5758#ifdef DARWIN_not_yet
    5859  if (use_mach_exception_handling) {
     
    6061  }
    6162#endif
    62   return pthread_kill((pthread_t)target->osid, SIGNAL_FOR_PROCESS_INTERRUPT);
     63  if (thread != (pthread_t) 0) {
     64    return pthread_kill(thread, SIGNAL_FOR_PROCESS_INTERRUPT);
     65  }
     66  return ESRCH;
    6367}
    6468
     
    11831187{
    11841188  int suspend_count = atomic_incf(&(tcr->suspend_count));
     1189  pthread_t thread;
    11851190  if (suspend_count == 1) {
    11861191#if SUSPEND_RESUME_VERBOSE
     
    11931198    }
    11941199#endif
    1195     if (pthread_kill((pthread_t)(tcr->osid), thread_suspend_signal) == 0) {
     1200    thread = (pthread_t)(tcr->osid);
     1201    if ((thread != (pthread_t) 0) &&
     1202        (pthread_kill(thread, thread_suspend_signal) == 0)) {
    11961203      SET_TCR_FLAG(tcr,TCR_FLAG_BIT_SUSPEND_ACK_PENDING);
    11971204    } else {
  • branches/working-0711-perf/ccl/lisp-kernel/x86-constants64.s

    r8039 r9701  
    2020
    2121
     22/*
     23
     24        Register usage in C calling conventions differ between
     25        Darwin/Linux/FreeBSD (which use the AMD-defined ABI) and
     26        Windows64 (which uses something else).  The good news is that
     27        Win64 did away with the cdecl/stdcall/fastcall madness, there
     28        is only one ABI left.  Here's a rundown.
     29
     30        AMD64^Wx86-64 ABI:
     31         * Integer and pointer function arguments passed (from left to
     32        right) in RDI, RSI, RDX, RCX, R8 and R9
     33         * FP arguments are passed in XMM0..XMM7
     34         * rest is passed on stack
     35         * return value in RAX
     36         * Callee must preserve RBP, RBX, R12..R15, MXCSR control bits
     37         * On function entry, x87 mode and DF clear is assumed
     38         * [RSP]..[RSP-128] must not be touched by signal handlers
     39
     40        Win64 ABI:
     41         * Integer and pointers passed in RCX, RDX, R8, R9
     42         * FP passed in XMM0..XMM3
     43         * rest is passed on stack
     44         * Return value in RAX or XMM0
     45         * Caller (!) responsible for creating and cleaning stack space for
     46        spilling integer registers
     47         * Callee must preserve RBP, RBX, RSI, RDI, R12..R15, XMM6..XMM15
     48
     49        Both want their stack pointers to be 16 byte aligned on call,
     50        equivalent to 8 byte offset after call due to pushed return address.
     51       
     52        http://msdn2.microsoft.com/en-us/library/zthk2dkh(VS.80).aspx
     53        http://www.tortall.net/projects/yasm/manual/html/objfmt-win64-exception.html
     54        http://www.x86-64.org/documentation/abi.pdf
     55
     56
     57        Lisp register usage:
     58
     59        Clozure CL renames the physical registers, giving them names
     60        based on their usage. An overview:
     61
     62        imm0..imm2
     63        temp0..temp2
     64        save0..save3
     65        arg_x, arg_y, arg_z
     66        fn
     67
     68        On top of that, further mappings are defined:
     69
     70        fname, next_method_context:     temp0
     71        nargs:                          imm2
     72        ra0:                            temp2
     73        xfn:                            temp1
     74        allocptr:                       temp0
     75        stack_temp:                     mm7     
     76       
     77        x86-64 ABI mapping:
     78       
     79        imm0..imm2:             RAX, RDX, RCX
     80        temp0..temp2:           RBX, R9, R10
     81        save0..save3:           R15, R14, R12, R11
     82        arg_x, arg_y, arg_z:    R8, RDI, RSI
     83        fn:                     R13
     84        rcontext_reg:           GS
     85
     86        Win64 specifics:
     87        rcontext_reg:           R11
     88       
     89*/
     90       
    2291
    2392/* Redefining these standard register names - with the same _l, _w, _b suffixes  */
     
    66135define([r15_b],[r15b])                                                 
    67136
     137/* Registers when using Lisp calling conventions */
     138       
    68139define([imm0],[rax])
    69140        define([imm0_l],[eax])
     
    150221        define([Rsave0],[15])   
    151222
     223
     224ifdef([WINDOWS],[
     225/* We keep the TCR pointer in r11 */
     226        define([rcontext_reg], r11)
     227        define([rcontext],[$1(%rcontext_reg)])
     228],[
    152229/* The TCR can be accessed relative to %gs   */
    153 define([rcontext],[gs])
     230        define([rcontext_reg],[gs])
     231        define([rcontext],[%rcontext_reg:$1])
     232])
    154233define([fname],[temp0])
    155234define([next_method_context],[temp0])
    156235define([nargs_b],[imm2_b])     
    157 define([nargs],[imm2_w])
     236define([nargs_w],[imm2_w])
    158237define([nargs_q],[imm2])
    159 define([nargs_l],[imm2_l])
     238define([nargs],[imm2_l])
    160239define([ra0],[temp2])       
    161240                                               
    162 define([xfn],[temp1])   
    163 
     241define([xfn],[temp1])
    164242
    165243define([allocptr],[temp0])             
     
    184262define([fp15],[xmm15])         
    185263define([fpzero],[fp15])
    186        
     264
     265/* Registers when running with native C calling conventions */
     266
     267define([cret],[rax])
     268        define([cret_l],[eax])
     269        define([cret_w],[ax])
     270        define([cret_b],[al])
     271        define([Rcret],[0])
     272       
     273define([ctemp0],[r10])
     274        define([ctemp0_l],[r10d])
     275        define([ctemp0_w],[r10w])
     276        define([ctemp0_b],[r10b])
     277        define([Rctemp0],[10])
     278       
     279define([ctemp1],[r11])         
     280        define([ctemp1_l],[r11d])
     281        define([ctemp1_w],[r11w])
     282        define([ctemp1_b],[r11b])
     283        define([Rctemp1],[11])
     284       
     285define([csave0],[rbx])
     286        define([csave0_l],[ebx])
     287        define([csave0_w],[bx])
     288        define([csave0_b],[bl])
     289        define([Rcsave0],[3])
     290
     291define([csave1],[r12])
     292        define([csave1_l],[r12d])
     293        define([csave1_w],[r12w])
     294        define([csave1_b],[r12b])
     295        define([Rcsave1],[12])
     296       
     297define([csave2],[r13])
     298        define([csave2_l],[r13d])
     299        define([csave2_w],[r13w])
     300        define([csave2_b],[r13b])
     301        define([Rcsave2],[13])
     302       
     303define([csave3],[r14])
     304        define([csave3_l],[r14d])
     305        define([csave3_w],[r14w])
     306        define([csave3_b],[r14b])
     307        define([Rcsave3],[14])
     308               
     309define([csave4],[r15])
     310        define([csave4_l],[r15d])
     311        define([csave4_w],[r15w])
     312        define([csave4_b],[r15b])
     313        define([Rcsave4],[15]) 
     314
     315ifdef([WINDOWS],[
     316
     317define([carg0],[rcx])
     318        define([carg0_l],[ecx])
     319        define([carg0_w],[cx])
     320        define([carg0_b],[cl])
     321        define([Rcarg0],[1])
     322       
     323define([carg1],[rdx])
     324        define([carg1_l],[edx])
     325        define([carg1_w],[dx])
     326        define([carg1_b],[dl])
     327        define([Rcarg1],[2])
     328       
     329define([carg2],[r8])
     330        define([carg2_l],[r8d])
     331        define([carg2_w],[r8w])
     332        define([carg2_b],[r8b])
     333        define([Rcarg2],[8])
     334
     335define([carg3],[r9])
     336        define([carg3_l],[r9d])
     337        define([carg3_w],[r9w])
     338        define([carg3_b],[r9b])
     339        define([Rcarg3],[9])
     340
     341define([csave5],[rsi])
     342        define([csave5_l],[esi])
     343        define([csave5_w],[si])
     344        define([csave5_b],[sil])
     345        define([csave5_z],[6])
     346
     347define([csave6],[rdi])
     348        define([csave6_l],[edi])
     349        define([csave6_w],[di])
     350        define([csave6_b],[dil])
     351        define([Rcsave6],[7])
     352
     353],[
     354       
     355define([carg0],[rdi])
     356        define([carg0_l],[edi])
     357        define([carg0_w],[di])
     358        define([carg0_b],[dil])
     359        define([Rcarg0],[7])
     360
     361define([carg1],[rsi])
     362        define([carg1_l],[esi])
     363        define([carg1_w],[si])
     364        define([carg1_b],[sil])
     365        define([carg1_z],[6])
     366
     367define([carg2],[rdx])
     368        define([carg2_l],[edx])
     369        define([carg2_w],[dx])
     370        define([carg2_b],[dl])
     371        define([Rcarg2],[2])
     372       
     373define([carg3],[rcx])
     374        define([carg3_l],[ecx])
     375        define([carg3_w],[cx])
     376        define([carg3_b],[cl])
     377        define([Rcarg3],[1])
     378       
     379define([carg4],[r8])
     380        define([carg4_l],[r8d])
     381        define([carg4_w],[r8w])
     382        define([carg4_b],[r8b])
     383        define([Rcarg4],[8])
     384
     385define([carg5],[r9])
     386        define([carg5_l],[r9d])
     387        define([carg5_w],[r9w])
     388        define([carg5_b],[r9b])
     389        define([Rcarg5],[9])   
     390])
    187391       
    188392nbits_in_word = 64
  • branches/working-0711-perf/ccl/lisp-kernel/x86-exceptions.c

    r8705 r9701  
    155155  area *a = active_dynamic_area;
    156156  Boolean egc_was_enabled = (a->older != NULL);
     157 
    157158  natural gc_previously_deferred = gc_deferred;
    158159
     
    217218      full_gc_deferred = 0;
    218219    }
    219     if (selector & GC_TRAP_FUNCTION_PURIFY) {
    220       purify_from_xp(xp, 0L);
    221       gc_from_xp(xp, 0L);
    222     }
    223     if (selector & GC_TRAP_FUNCTION_SAVE_APPLICATION) {
    224       OSErr err;
    225       extern OSErr save_application(unsigned);
    226       area *vsarea = tcr->vs_area;
     220    if (selector > GC_TRAP_FUNCTION_GC) {
     221      if (selector & GC_TRAP_FUNCTION_IMPURIFY) {
     222        impurify_from_xp(xp, 0L);
     223        /*        nrs_GC_EVENT_STATUS_BITS.vcell |= gc_integrity_check_bit; */
     224        gc_from_xp(xp, 0L);
     225        release_readonly_area();
     226      }
     227      if (selector & GC_TRAP_FUNCTION_PURIFY) {
     228        purify_from_xp(xp, 0L);
     229        gc_from_xp(xp, 0L);
     230      }
     231      if (selector & GC_TRAP_FUNCTION_SAVE_APPLICATION) {
     232        OSErr err;
     233        extern OSErr save_application(unsigned);
     234        area *vsarea = tcr->vs_area;
    227235       
    228       nrs_TOPLFUNC.vcell = *((LispObj *)(vsarea->high)-1);
    229       err = save_application(arg);
    230       if (err == noErr) {
    231         _exit(0);
     236        nrs_TOPLFUNC.vcell = *((LispObj *)(vsarea->high)-1);
     237        err = save_application(arg);
     238        if (err == noErr) {
     239          _exit(0);
     240        }
     241        fatal_oserr(": save_application", err);
    232242      }
    233       fatal_oserr(": save_application", err);
    234     }
    235     switch (selector) {
    236     case GC_TRAP_FUNCTION_SET_HONS_AREA_SIZE:
    237       xpGPR(xp, Iimm0) = 0;
    238       break;
    239     case GC_TRAP_FUNCTION_FREEZE:
    240       a->active = (BytePtr) align_to_power_of_2(a->active, log2_page_size);
    241       tenured_area->static_dnodes = area_dnode(a->active, a->low);
    242       xpGPR(xp, Iimm0) = tenured_area->static_dnodes << dnode_shift;
    243       break;
    244     default:
    245       break;
     243      switch (selector) {
     244      case GC_TRAP_FUNCTION_SET_HONS_AREA_SIZE:
     245        xpGPR(xp, Iimm0) = 0;
     246        break;
     247      case GC_TRAP_FUNCTION_FREEZE:
     248        a->active = (BytePtr) align_to_power_of_2(a->active, log2_page_size);
     249        tenured_area->static_dnodes = area_dnode(a->active, a->low);
     250        xpGPR(xp, Iimm0) = tenured_area->static_dnodes << dnode_shift;
     251        break;
     252      default:
     253        break;
     254      }
    246255    }
    247256    if (egc_was_enabled) {
     
    423432}
    424433
    425 extern unsigned get_mxcsr();
    426 extern void set_mxcsr(unsigned);
    427434 
    428435int
     
    430437                  natural arg1, natural arg2, natural arg3, natural arg4, natural arg5)
    431438{
    432   sigset_t mask;
    433439  natural  callback_ptr, i;
    434440  int delta;
     
    636642      handler = protection_handlers[a->why];
    637643      return handler(xp, a, addr);
     644    } else {
     645      if ((addr >= readonly_area->low) &&
     646          (addr < readonly_area->active)) {
     647        UnProtectMemory((LogicalAddress)(truncate_to_power_of_2(addr,log2_page_size)),
     648                        page_size);
     649        return true;
     650      }
    638651    }
    639652  }
     
    839852    if ((program_counter[0] == XUUO_OPCODE_0) &&
    840853        (program_counter[1] == XUUO_OPCODE_1)) {
     854      TCR *target = (TCR *)xpGPR(context, Iarg_z);
     855
    841856      switch (program_counter[2]) {
    842857      case XUUO_TLB_TOO_SMALL:
     
    853868
    854869      case XUUO_SUSPEND_NOW:
     870        xpPC(context)+=3;
     871        return true;
     872
     873      case XUUO_INTERRUPT:
     874        raise_thread_interrupt(target);
     875        xpPC(context)+=3;
     876        return true;
     877
     878      case XUUO_SUSPEND:
     879        xpGPR(context,Iimm0) = (LispObj) lisp_suspend_tcr(target);
     880        xpPC(context)+=3;
     881        return true;
     882
     883      case XUUO_SUSPEND_ALL:
     884        lisp_suspend_other_threads();
     885        xpPC(context)+=3;
     886        return true;
     887
     888
     889      case XUUO_RESUME:
     890        xpGPR(context,Iimm0) = (LispObj) lisp_resume_tcr(target);
     891        xpPC(context)+=3;
     892        return true;
     893       
     894      case XUUO_RESUME_ALL:
     895        lisp_resume_other_threads();
    855896        xpPC(context)+=3;
    856897        return true;
     
    13631404#endif
    13641405  sa.sa_flags =
    1365 #if 1
    1366     0
    1367 #else
    1368     SA_RESTART
    1369 #endif
     1406    0 /* SA_RESTART */
    13701407#ifdef USE_SIGALTSTACK
    13711408    | SA_ONSTACK
     
    15701607{
    15711608  thread_suspend_signal = SIG_SUSPEND_THREAD;
    1572   thread_resume_signal = SIG_RESUME_THREAD;
    15731609
    15741610  install_signal_handler(thread_suspend_signal, (void *)SUSPEND_RESUME_HANDLER);
    1575   install_signal_handler(thread_resume_signal, (void *)SUSPEND_RESUME_HANDLER);
    15761611  install_signal_handler(SIGQUIT, (void *)QUIT_HANDLER);
    15771612}
  • branches/working-0711-perf/ccl/lisp-kernel/x86-exceptions.h

    r7836 r9701  
    7373#define xpGPRvector(x) ((DWORD64 *)((x)->ContextRecord))
    7474#define xpGPR(x,gprno) (xpGPRvector(x)[gprno])
    75 #define xpPC(x) xpGPR(x,Iip);
     75#define xpPC(x) xpGPR(x,Iip)
    7676#endif
    7777
    7878#ifdef DARWIN
    79 #define SIGNAL_FOR_PROCESS_INTERRUPT SIGEMT
     79#define SIGNAL_FOR_PROCESS_INTERRUPT SIGUSR1
    8080#endif
    8181#ifdef LINUX
     
    105105#define XUUO_INTERRUPT_NOW 2
    106106#define XUUO_SUSPEND_NOW 3
     107#define XUUO_INTERRUPT 4
     108#define XUUO_SUSPEND 5
     109#define XUUO_SUSPEND_ALL 6
     110#define XUUO_RESUME 7
     111#define XUUO_RESUME_ALL 8
    107112
    108113void
     
    168173#define RECOVER_FN_FROM_RIP_WORD0 0x8d4c /* 0x4c 0x8d, little-endian */
    169174#define RECOVER_FN_FROM_RIP_BYTE2 0x2d  /* third byte of opcode */
     175
     176extern natural get_mxcsr();
     177extern void set_mxcsr(natural);
  • branches/working-0711-perf/ccl/lisp-kernel/x86-gc.c

    r7680 r9701  
    2525#include <string.h>
    2626#include <sys/time.h>
    27 
    28 #ifndef timeradd
    29 # define timeradd(a, b, result)                                               \
    30   do {                                                                        \
    31     (result)->tv_sec = (a)->tv_sec + (b)->tv_sec;                             \
    32     (result)->tv_usec = (a)->tv_usec + (b)->tv_usec;                          \
    33     if ((result)->tv_usec >= 1000000)                                         \
    34       {                                                                       \
    35         ++(result)->tv_sec;                                                   \
    36         (result)->tv_usec -= 1000000;                                         \
    37       }                                                                       \
    38   } while (0)
    39 #endif
    40 #ifndef timersub
    41 # define timersub(a, b, result)                                               \
    42   do {                                                                        \
    43     (result)->tv_sec = (a)->tv_sec - (b)->tv_sec;                             \
    44     (result)->tv_usec = (a)->tv_usec - (b)->tv_usec;                          \
    45     if ((result)->tv_usec < 0) {                                              \
    46       --(result)->tv_sec;                                                     \
    47       (result)->tv_usec += 1000000;                                           \
    48     }                                                                         \
    49   } while (0)
    50 #endif
    5127
    5228
     
    349325          ((hash_table_vector_header *) base)->cache_key = undefined;
    350326          ((hash_table_vector_header *) base)->cache_value = lisp_nil;
     327          mark_weak_htabv(n);
     328          return;
    351329        }
    352         deref(ptr_to_lispobj(base),1) = GCweakvll;
    353         GCweakvll = n;
    354         return;
    355330      }
    356331
     
    518493          ((hash_table_vector_header *) base)->cache_key = undefined;
    519494          ((hash_table_vector_header *) base)->cache_value = lisp_nil;
     495          mark_weak_htabv(n);
     496          return;
    520497        }
    521         deref(ptr_to_lispobj(base),1) = GCweakvll;
    522         GCweakvll = n;
    523         return;
    524498      }
    525499
     
    758732        ((hash_table_vector_header *) base)->cache_key = undefined;
    759733        ((hash_table_vector_header *) base)->cache_value = lisp_nil;
    760       }
    761 
    762       deref(ptr_to_lispobj(base),1) = GCweakvll;
    763       GCweakvll = this;
    764       goto Climb;
     734        dws_mark_weak_htabv(this);
     735        element_count = hash_table_vector_header_count;
     736      }
    765737    }
    766738
     
    1023995          ((hash_table_vector_header *) start)->cache_key = undefined;
    1024996          ((hash_table_vector_header *) start)->cache_value = lisp_nil;
    1025         }
    1026 
    1027         start[1] = GCweakvll;
    1028         GCweakvll = (LispObj) (((natural) start) + fulltag_misc);
    1029       } else {
    1030 
    1031         if (subtag == subtag_pool) {
    1032           start[1] = lisp_nil;
    1033         }
    1034 
    1035         if (subtag == subtag_weak) {
    1036           natural weak_type = (natural) start[2];
    1037           if (weak_type >> population_termination_bit)
    1038             element_count -= 2;
    1039           else
    1040             element_count -= 1;
    1041           start[1] = GCweakvll;
    1042           GCweakvll = (LispObj) (((natural) start) + fulltag_misc);   
    1043         }
    1044 
    1045         base = start + element_count + 1;
    1046         if (subtag == subtag_function) {
    1047           element_count -= (int)start[1];
     997          mark_weak_htabv((LispObj)start);
     998          element_count = 0;
    1048999        }
    1049         while(element_count--) {
    1050           mark_root(*--base);
    1051         }
     1000      }
     1001      if (subtag == subtag_pool) {
     1002        start[1] = lisp_nil;
     1003      }
     1004
     1005      if (subtag == subtag_weak) {
     1006        natural weak_type = (natural) start[2];
     1007        if (weak_type >> population_termination_bit)
     1008          element_count -= 2;
     1009        else
     1010          element_count -= 1;
     1011        start[1] = GCweakvll;
     1012        GCweakvll = (LispObj) (((natural) start) + fulltag_misc);   
     1013      }
     1014
     1015      base = start + element_count + 1;
     1016      if (subtag == subtag_function) {
     1017        element_count -= (int)start[1];
     1018      }
     1019      while(element_count--) {
     1020        mark_root(*--base);
    10521021      }
    10531022      start += size;
     
    13221291      if ((header_subtag(node) == subtag_hash_vector) &&
    13231292          ((((hash_table_vector_header *)p)->flags) & nhash_track_keys_mask)) {
    1324         natural skip = (sizeof(hash_table_vector_header)/sizeof(LispObj))-1;
     1293        natural skip = hash_table_vector_header_count-1;
    13251294        hashp = (hash_table_vector_header *) p;
    13261295        p++;
     
    16871656    new;
    16881657  natural
    1689     subtag = header_subtag(header),
    1690     element_count = header_element_count(header),
     1658    start = (natural)old,
    16911659    physbytes;
    16921660
    1693   switch(subtag) {
    1694   case subtag_simple_base_string:
    1695     physbytes = node_size + (element_count << 2);
    1696     break;
    1697 
    1698 #ifndef X86
    1699   case subtag_code_vector:
    1700     physbytes = node_size + (element_count << 2);
    1701     break;
    1702 #endif
    1703 
    1704   default:
    1705     Bug(NULL, "Can't purify object at 0x%08x", obj);
    1706     return obj;
    1707   }
    1708   physbytes = (physbytes+(dnode_size-1))&~(dnode_size-1);
     1661  physbytes = ((natural)(skip_over_ivector(start,header))) - start;
     1662
    17091663  dest->active += physbytes;
    17101664
     
    17371691
    17381692
    1739 #define FORWARD_ONLY 0
    1740 #define COPY_CODE (1<<0)
    1741 #define COPY_STRINGS (1<<1)
    17421693
    17431694
     
    17941745
    17951746Boolean
    1796 copy_ivector_reference(LispObj *ref, BytePtr low, BytePtr high, area *dest, int what_to_copy)
     1747copy_ivector_reference(LispObj *ref, BytePtr low, BytePtr high, area *dest)
    17971748{
    17981749  LispObj obj = *ref, header, new;
     
    18101761      header_tag = fulltag_of(header);
    18111762      if (immheader_tag_p(header_tag)) {
    1812         header_subtag = header_subtag(header);
    1813         if ((what_to_copy & COPY_STRINGS) &&
    1814             ((header_subtag == subtag_simple_base_string))) {
     1763        if (header_subtag(header) != subtag_macptr) {
    18151764          new = purify_object(obj, dest);
    18161765          *ref = new;
     
    18241773
    18251774
    1826 void purify_headerless_range(LispObj *start, LispObj *end, BytePtr low, BytePtr high, area *to, int what)
     1775void
     1776purify_gcable_ptrs(BytePtr low, BytePtr high, area *to)
     1777{
     1778  LispObj *prev = &(lisp_global(GCABLE_POINTERS)), next;
     1779
     1780  while ((*prev) != (LispObj)NULL) {
     1781    copy_ivector_reference(prev, low, high, to);
     1782    next = *prev;
     1783    prev = &(((xmacptr *)ptr_from_lispobj(untag(next)))->link);
     1784  }
     1785}
     1786
     1787void
     1788purify_headerless_range(LispObj *start, LispObj *end, BytePtr low, BytePtr high, area *to)
    18271789{
    18281790  while (start < end) {
    1829     copy_ivector_reference(start, low, high, to, what);
     1791    copy_ivector_reference(start, low, high, to);
    18301792    start++;
    18311793  }
     
    18331795   
    18341796void
    1835 purify_range(LispObj *start, LispObj *end, BytePtr low, BytePtr high, area *to, int what)
     1797purify_range(LispObj *start, LispObj *end, BytePtr low, BytePtr high, area *to)
    18361798{
    18371799  LispObj header;
     
    18601822          nwords -= skip;
    18611823          while(skip--) {
    1862             copy_ivector_reference(start, low, high, to, what);
     1824            copy_ivector_reference(start, low, high, to);
    18631825            start++;
    18641826          }
     
    18691831          nwords >>= 1;
    18701832          while(nwords--) {
    1871             if (copy_ivector_reference(start, low, high, to, what) && hashp) {
     1833            if (copy_ivector_reference(start, low, high, to) && hashp) {
    18721834              hashp->flags |= nhash_key_moved_mask;
    18731835              hashp = NULL;
    18741836            }
    18751837            start++;
    1876             copy_ivector_reference(start, low, high, to, what);
     1838            copy_ivector_reference(start, low, high, to);
    18771839            start++;
    18781840          }
     
    18861848          start++;
    18871849          while(nwords--) {
    1888             copy_ivector_reference(start, low, high, to, what);
     1850            copy_ivector_reference(start, low, high, to);
    18891851            start++;
    18901852          }
     
    18921854      } else {
    18931855        /* Not a header, just a cons cell */
    1894         copy_ivector_reference(start, low, high, to, what);
     1856        copy_ivector_reference(start, low, high, to);
    18951857        start++;
    1896         copy_ivector_reference(start, low, high, to, what);
     1858        copy_ivector_reference(start, low, high, to);
    18971859        start++;
    18981860      }
     
    19031865/* Purify references from tstack areas */
    19041866void
    1905 purify_tstack_area(area *a, BytePtr low, BytePtr high, area *to, int what)
     1867purify_tstack_area(area *a, BytePtr low, BytePtr high, area *to)
    19061868{
    19071869  LispObj
     
    19171879    next = (LispObj *) ptr_from_lispobj(*current);
    19181880    end = ((next >= start) && (next < limit)) ? next : limit;
    1919     if (current[1] == 0) {
    1920       purify_range(current+2, end, low, high, to, what);
    1921     }
     1881    purify_range(current+2, end, low, high, to);
    19221882  }
    19231883}
     
    19251885/* Purify a vstack area */
    19261886void
    1927 purify_vstack_area(area *a, BytePtr low, BytePtr high, area *to, int what)
     1887purify_vstack_area(area *a, BytePtr low, BytePtr high, area *to)
    19281888{
    19291889  LispObj
     
    19311891    *q = (LispObj *) a->high;
    19321892 
    1933   purify_headerless_range(p, q, low, high, to, what);
    1934 }
    1935 
    1936 
    1937 void
    1938 purify_xp(ExceptionInformation *xp, BytePtr low, BytePtr high, area *to, int what)
     1893  purify_headerless_range(p, q, low, high, to);
     1894}
     1895
     1896
     1897void
     1898purify_xp(ExceptionInformation *xp, BytePtr low, BytePtr high, area *to)
    19391899{
    19401900  natural *regs = (natural *) xpGPRvector(xp);
     
    19421902
    19431903#ifdef X8664
    1944   copy_ivector_reference(&(regs[Iarg_z]), low, high, to, what);
    1945   copy_ivector_reference(&(regs[Iarg_y]), low, high, to, what);
    1946   copy_ivector_reference(&(regs[Iarg_x]), low, high, to, what);
    1947   copy_ivector_reference(&(regs[Isave3]), low, high, to, what);
    1948   copy_ivector_reference(&(regs[Isave2]), low, high, to, what);
    1949   copy_ivector_reference(&(regs[Isave1]), low, high, to, what);
    1950   copy_ivector_reference(&(regs[Isave0]), low, high, to, what);
    1951   copy_ivector_reference(&(regs[Ifn]), low, high, to, what);
    1952   copy_ivector_reference(&(regs[Itemp0]), low, high, to, what);
    1953   copy_ivector_reference(&(regs[Itemp1]), low, high, to, what);
    1954   copy_ivector_reference(&(regs[Itemp2]), low, high, to, what);
     1904  copy_ivector_reference(&(regs[Iarg_z]), low, high, to);
     1905  copy_ivector_reference(&(regs[Iarg_y]), low, high, to);
     1906  copy_ivector_reference(&(regs[Iarg_x]), low, high, to);
     1907  copy_ivector_reference(&(regs[Isave3]), low, high, to);
     1908  copy_ivector_reference(&(regs[Isave2]), low, high, to);
     1909  copy_ivector_reference(&(regs[Isave1]), low, high, to);
     1910  copy_ivector_reference(&(regs[Isave0]), low, high, to);
     1911  copy_ivector_reference(&(regs[Ifn]), low, high, to);
     1912  copy_ivector_reference(&(regs[Itemp0]), low, high, to);
     1913  copy_ivector_reference(&(regs[Itemp1]), low, high, to);
     1914  copy_ivector_reference(&(regs[Itemp2]), low, high, to);
    19551915#if 0
    1956   purify_locref(&(regs[Iip]), low, high, to, what);
     1916  purify_locref(&(regs[Iip]), low, high, to);
    19571917#endif
    19581918#else
     
    19611921
    19621922void
    1963 purify_tcr_tlb(TCR *tcr, BytePtr low, BytePtr high, area *to, int what)
     1923purify_tcr_tlb(TCR *tcr, BytePtr low, BytePtr high, area *to)
    19641924{
    19651925  natural n = tcr->tlb_limit;
    19661926  LispObj *start = tcr->tlb_pointer, *end = (LispObj *) ((BytePtr)start+n);
    19671927
    1968   purify_range(start, end, low, high, to, what);
    1969 }
    1970 
    1971 void
    1972 purify_tcr_xframes(TCR *tcr, BytePtr low, BytePtr high, area *to, int what)
     1928  purify_range(start, end, low, high, to);
     1929}
     1930
     1931void
     1932purify_tcr_xframes(TCR *tcr, BytePtr low, BytePtr high, area *to)
    19731933{
    19741934  xframe_list *xframes;
     
    19771937  xp = tcr->gc_context;
    19781938  if (xp) {
    1979     purify_xp(xp, low, high, to, what);
     1939    purify_xp(xp, low, high, to);
    19801940  }
    19811941
    19821942  for (xframes = tcr->xframe; xframes; xframes = xframes->prev) {
    1983     purify_xp(xframes->curr, low, high, to, what);
    1984   }
    1985 }
    1986 
    1987 
    1988 void
    1989 purify_areas(BytePtr low, BytePtr high, area *target, int what)
     1943    purify_xp(xframes->curr, low, high, to);
     1944  }
     1945}
     1946
     1947
     1948void
     1949purify_areas(BytePtr low, BytePtr high, area *target)
    19901950{
    19911951  area *next_area;
     
    19951955    switch (code) {
    19961956    case AREA_TSTACK:
    1997       purify_tstack_area(next_area, low, high, target, what);
     1957      purify_tstack_area(next_area, low, high, target);
    19981958      break;
    19991959     
    20001960    case AREA_VSTACK:
    2001       purify_vstack_area(next_area, low, high, target, what);
     1961      purify_vstack_area(next_area, low, high, target);
    20021962      break;
    20031963     
    20041964    case AREA_CSTACK:
    2005 #ifdef PPC
    2006       purify_cstack_area(next_area, low, high, target, what);
    2007 #endif
    20081965      break;
    20091966     
    20101967    case AREA_STATIC:
    20111968    case AREA_DYNAMIC:
    2012       purify_range((LispObj *) next_area->low, (LispObj *) next_area->active, low, high, target, what);
     1969      purify_range((LispObj *) next_area->low, (LispObj *) next_area->active, low, high, target);
    20131970      break;
    20141971     
     
    20421999
    20432000
    2044   max_pure_size = interned_pname_bytes_in_range((LispObj *)(a->low + (static_dnodes_for_area(a) << dnode_shift)),
     2001  max_pure_size = unboxed_bytes_in_range((LispObj *)(a->low + (static_dnodes_for_area(a) << dnode_shift)),
    20452002                                         (LispObj *) a->active);
    20462003  new_pure_area = extend_readonly_area(max_pure_size);
     
    20502007
    20512008    /*
    2052       First, loop thru *all-packages* and purify the pnames of all
    2053       interned symbols.  Then walk every place that could reference
    2054       a heap-allocated object (all_areas, the xframe_list) and
    2055       purify code_vectors (and update the odd case of a shared
    2056       reference to a pname.)
     2009
    20572010       
    20582011      Make the new_pure_area executable, just in case.
     
    20622015      */
    20632016
    2064     {
    2065       lispsymbol *rawsym = (lispsymbol *)(&(nrs_ALL_PACKAGES));
    2066       LispObj pkg_list = rawsym->vcell, htab, obj;
    2067       package *p;
    2068       cons *c;
    2069       natural elements, i;
    2070 
    2071       while (fulltag_of(pkg_list) == fulltag_cons) {
    2072         c = (cons *) ptr_from_lispobj(untag(pkg_list));
    2073         p = (package *) ptr_from_lispobj(untag(c->car));
    2074         pkg_list = c->cdr;
    2075         c = (cons *) ptr_from_lispobj(untag(p->itab));
    2076         htab = c->car;
    2077         elements = header_element_count(header_of(htab));
    2078         for (i = 1; i<= elements; i++) {
    2079           obj = deref(htab,i);
    2080           if (fulltag_of(obj) == fulltag_symbol) {
    2081             rawsym = (lispsymbol *) ptr_from_lispobj(untag(obj));
    2082             copy_ivector_reference(&(rawsym->pname), a->low, a->active, new_pure_area, COPY_STRINGS);
    2083           }
    2084         }
    2085         c = (cons *) ptr_from_lispobj(untag(p->etab));
    2086         htab = c->car;
    2087         elements = header_element_count(header_of(htab));
    2088         for (i = 1; i<= elements; i++) {
    2089           obj = deref(htab,i);
    2090           if (fulltag_of(obj) == fulltag_symbol) {
    2091             rawsym = (lispsymbol *) ptr_from_lispobj(untag(obj));
    2092             copy_ivector_reference(&(rawsym->pname), a->low, a->active, new_pure_area, COPY_STRINGS);
    2093           }
    2094         }
    2095       }
    2096     }
     2017
    20972018   
    2098     purify_areas(a->low, a->active, new_pure_area, FORWARD_ONLY);
     2019    purify_areas(a->low, a->active, new_pure_area);
    20992020   
    21002021    other_tcr = tcr;
    21012022    do {
    2102       purify_tcr_xframes(other_tcr, a->low, a->active, new_pure_area, FORWARD_ONLY);
    2103       purify_tcr_tlb(other_tcr, a->low, a->active, new_pure_area, FORWARD_ONLY);
     2023      purify_tcr_xframes(other_tcr, a->low, a->active, new_pure_area);
     2024      purify_tcr_tlb(other_tcr, a->low, a->active, new_pure_area);
    21042025      other_tcr = other_tcr->next;
    21052026    } while (other_tcr != tcr);
    21062027
    2107 
     2028    purify_gcable_ptrs(a->low, a->active, new_pure_area);
    21082029    {
    21092030      natural puresize = (unsigned) (new_pure_area->active-new_pure_start);
     
    21402061 
    21412062
    2142 
    2143 void
    2144 impurify_xp(ExceptionInformation *xp, LispObj low, LispObj high, int delta)
     2063void
     2064impurify_gcable_ptrs(LispObj low, LispObj high, signed_natural delta)
     2065{
     2066  LispObj *prev = &(lisp_global(GCABLE_POINTERS)), next;
     2067
     2068  while ((*prev) != (LispObj)NULL) {
     2069    impurify_noderef(prev, low, high, delta);
     2070    next = *prev;
     2071    prev = &(((xmacptr *)ptr_from_lispobj(untag(next)))->link);
     2072  }
     2073}
     2074
     2075
     2076void
     2077impurify_xp(ExceptionInformation *xp, LispObj low, LispObj high, signed_natural delta)
    21452078{
    21462079  natural *regs = (natural *) xpGPRvector(xp);
     
    21672100
    21682101void
    2169 impurify_headerless_range(LispObj *start, LispObj *end, LispObj low, LispObj high, int delta)
     2102impurify_headerless_range(LispObj *start, LispObj *end, LispObj low, LispObj high, signed_natural delta)
    21702103{
    21712104  while (start < end) {
     
    21772110
    21782111void
    2179 impurify_range(LispObj *start, LispObj *end, LispObj low, LispObj high, int delta)
     2112impurify_range(LispObj *start, LispObj *end, LispObj low, LispObj high, signed_natural delta)
    21802113{
    21812114  LispObj header;
     
    22492182
    22502183void
    2251 impurify_tcr_tlb(TCR *tcr,  LispObj low, LispObj high, int delta)
     2184impurify_tcr_tlb(TCR *tcr,  LispObj low, LispObj high, signed_natural delta)
    22522185{
    22532186  unsigned n = tcr->tlb_limit;
     
    22582191
    22592192void
    2260 impurify_tcr_xframes(TCR *tcr, LispObj low, LispObj high, int delta)
     2193impurify_tcr_xframes(TCR *tcr, LispObj low, LispObj high, signed_natural delta)
    22612194{
    22622195  xframe_list *xframes;
     
    22742207
    22752208void
    2276 impurify_tstack_area(area *a, LispObj low, LispObj high, int delta)
     2209impurify_tstack_area(area *a, LispObj low, LispObj high, signed_natural delta)
    22772210{
    22782211  LispObj
     
    22942227}
    22952228void
    2296 impurify_vstack_area(area *a, LispObj low, LispObj high, int delta)
     2229impurify_vstack_area(area *a, LispObj low, LispObj high, signed_natural delta)
    22972230{
    22982231  LispObj
     
    23052238
    23062239void
    2307 impurify_areas(LispObj low, LispObj high, int delta)
     2240impurify_areas(LispObj low, LispObj high, signed_natural delta)
    23082241{
    23092242  area *next_area;
     
    23212254     
    23222255    case AREA_CSTACK:
    2323 #ifdef PPC
    2324       impurify_cstack_area(next_area, low, high, delta);
    2325 #endif
    23262256      break;
    23272257     
     
    23372267}
    23382268
     2269#ifdef WINDOWS
     2270int
     2271impurify(TCR *tcr, signed_natural param)
     2272{
     2273}
     2274#else
    23392275int
    23402276impurify(TCR *tcr, signed_natural param)
     
    23472283      oldhigh = a->high, newhigh;
    23482284    unsigned n = ro_limit - ro_base;
    2349     int delta = oldfree-ro_base;
     2285    signed_natural delta = oldfree-ro_base;
    23502286    TCR *other_tcr;
    23512287
     
    23722308        other_tcr = other_tcr->next;
    23732309      } while (other_tcr != tcr);
     2310
     2311      impurify_gcable_ptrs(ptr_to_lispobj(ro_base), ptr_to_lispobj(ro_limit), delta);
    23742312      lisp_global(IN_GC) = 0;
    23752313    }
     
    23782316  return -1;
    23792317}
     2318#endif
  • branches/working-0711-perf/ccl/lisp-kernel/x86-macros.s

    r8040 r9701  
    2020                                       
    2121define([ref_global],[
    22         mov lisp_global($1),$2
     22        __(mov lisp_global($1),$2)
    2323])
    2424
    2525define([set_global],[
    26         mov $1,lisp_global($2)
     26        __(mov $1,lisp_global($2))
    2727])
    2828
    2929define([ref_nrs_value],[
    30         mov nrs.$1+symbol.vcell,$2
     30        __(mov nrs.$1+symbol.vcell,$2)
    3131])
    3232       
    3333define([set_nrs_value],[
    34         mov $1,nrs.$2+symbol.vcell
     34        __(mov $1,nrs.$2+symbol.vcell)
    3535])
    3636                                                       
    3737define([unbox_fixnum],[
    38         mov $1,$2
    39         sar [$]fixnumshift,$2
     38        __(mov $1,$2)
     39        __(sar [$]fixnumshift,$2)
    4040])
    4141
    4242define([box_fixnum],[
    43         imulq [$]fixnumone,$1,$2
     43        __(imulq [$]fixnumone,$1,$2)
    4444])     
    4545
     
    4747/* box_fixnum, with no effect on flags */
    4848define([box_fixnum_no_flags],[
    49         leaq (,$1,8),$2
     49        __(leaq (,$1,8),$2)
    5050])
    5151                               
    52 define([save_node_regs],[
    53         push %arg_z
    54         push %arg_y
    55         push %arg_x
    56         push %temp0
    57         push %temp1
    58         push %temp2
    59         push %save0
    60         push %save1
    61         push %save2
    62         push %save3
    63         push %ra0
    64         push %fn
    65 ])
    66 
    67 /* This needs to be done before we transition back to the lisp stack  */
    68 /* from the foreign stack.   */
    69                
    70 define([zero_node_regs],[
    71         xor %fn,%fn
    72         mov %fn,%ra0
    73         mov %fn,%save3
    74         mov %fn,%save2
    75         mov %fn,%save1
    76         mov %fn,%save0
    77         mov %fn,%temp2
    78         mov %fn,%temp1
    79         mov %fn,%temp0
    80         mov %fn,%arg_x
    81         mov %fn,%arg_y
    82         mov %fn,arg_z
    83 ])     
    84 define([restore_node_regs],[
    85         pop %fn
    86         pop %ra0
    87         pop %save3
    88         pop %save2
    89         pop %save1
    90         pop %save0
    91         pop %temp2
    92         pop %temp1
    93         pop %temp0
    94         pop %arg_x
    95         pop %arg_y
    96         pop %arg_z
    97 ])     
    9852
    9953/* Zero $3 bytes worth of dnodes, starting at offset $2 relative  */
     
    10458        .macro zero_dnodes
    10559        .if $2
    106         movapd %fpzero,$1($0)
    107         zero_dnodes $0,$1+dnode_size,$2-dnode_size
     60        __(movapd %fpzero,$1($0))
     61        __(zero_dnodes $0,$1+dnode_size,$2-dnode_size)
    10862        .endif
    10963        .endmacro
     
    11165        .macro zero_dnodes base,disp,nbytes
    11266        .ifgt \nbytes
    113         movapd %fpzero,\disp(\base)
     67        movapd %fpzero,\disp(\base)
    11468        zero_dnodes \base,"\disp+dnode_size","\nbytes-dnode_size"
    11569        .endif
     
    12377define([TSP_Alloc_Fixed],[
    12478        define([TSP_Alloc_Size],[((($1+node_size) & ~(dnode_size-1))+dnode_size)])
    125         subq [$]TSP_Alloc_Size,%rcontext:tcr.next_tsp
    126         movq %rcontext:tcr.save_tsp,%stack_temp
    127         movq %rcontext:tcr.next_tsp,$2
     79        __(subq [$]TSP_Alloc_Size,rcontext(tcr.next_tsp))
     80        __(movq rcontext(tcr.save_tsp),%stack_temp)
     81        __(movq rcontext(tcr.next_tsp),$2)
    12882        zero_dnodes $2,0,TSP_Alloc_Size
    129         movq %stack_temp,($2)
    130         movq %rbp,tsp_frame.save_rbp($2)
    131         movq $2,%rcontext:tcr.save_tsp
     83        __(movq %stack_temp,($2))
     84        __(movq %rbp,tsp_frame.save_rbp($2))
     85        __(movq $2,rcontext(tcr.save_tsp))
    13286        undefine([TSP_Alloc_Size])
    13387])
     
    13892define([TSP_Alloc_Var],[
    13993        new_macro_labels()
    140         subq $1,%rcontext:tcr.next_tsp
    141         movq %rcontext:tcr.save_tsp,%stack_temp
    142         movq %rcontext:tcr.next_tsp,$2
    143         jmp macro_label(test)
     94        subq $1,rcontext(tcr.next_tsp)
     95        __(movq rcontext(tcr.save_tsp),%stack_temp)
     96        __(movq rcontext(tcr.next_tsp),$2)
     97        __(jmp macro_label(test))
    14498macro_label(loop):
    145         movapd %fpzero,0($2)
    146         addq $dnode_size,$2
     99        __(movapd %fpzero,0($2))
     100        __(addq $dnode_size,$2)
    147101macro_label(test):     
    148         subq $dnode_size,$1
    149         jge macro_label(loop)
    150         movq %rcontext:tcr.next_tsp,$2
    151         movd %stack_temp,$1
    152         movq $1,($2)
    153         movq %rbp,tsp_frame.save_rbp($2)
    154         movq $2,%rcontext:tcr.save_tsp
    155         addq $dnode_size,$2
     102        __(subq $dnode_size,$1)
     103        __(jge macro_label(loop))
     104        __(movq rcontext(tcr.next_tsp),$2)
     105        __(movd %stack_temp,$1)
     106        __(movq $1,($2))
     107        __(movq %rbp,tsp_frame.save_rbp($2))
     108        __(movq $2,rcontext(tcr.save_tsp))
     109        __(addq $dnode_size,$2)
    156110])
    157111       
     
    160114define([Allocate_Catch_Frame],[
    161115        TSP_Alloc_Fixed(catch_frame.size,$1)
    162         movq [$](catch_frame.element_count<<subtag_shift)|subtag_catch_frame,dnode_size($1)
    163         addq [$]dnode_size+fulltag_misc,$1
     116        __(movq [$](catch_frame.element_count<<subtag_shift)|subtag_catch_frame,dnode_size($1))
     117        __(addq [$]dnode_size+fulltag_misc,$1)
    164118])
    165119
     
    168122define([Make_Catch],[
    169123        Allocate_Catch_Frame(%imm2)
    170         movq %rcontext:tcr.catch_top,%imm0
    171         movq %rcontext:tcr.db_link,%imm1
    172         movq %arg_z,catch_frame.catch_tag(%imm2)
    173         movq %imm0,catch_frame.link(%imm2)
    174         movq [$]$1,catch_frame.mvflag(%imm2)
    175         movq %rcontext:tcr.xframe,%imm0
    176         movq %rsp,catch_frame.rsp(%imm2)
    177         movq %rbp,catch_frame.rbp(%imm2)
    178         movq %rcontext:tcr.foreign_sp,%stack_temp
    179         movq %imm1,catch_frame.db_link(%imm2)
    180         movq %save3,catch_frame._save3(%imm2)
    181         movq %save2,catch_frame._save2(%imm2)
    182         movq %save1,catch_frame._save1(%imm2)
    183         movq %save0,catch_frame._save0(%imm2)
    184         movq %imm0,catch_frame.xframe(%imm2)
    185         movq %stack_temp,catch_frame.foreign_sp(%imm2)
    186         movq %xfn,catch_frame.pc(%imm2)
    187         movq %imm2,%rcontext:tcr.catch_top
     124        __(movq rcontext(tcr.catch_top),%imm0)
     125        __(movq rcontext(tcr.db_link),%imm1)
     126        __(movq %arg_z,catch_frame.catch_tag(%imm2))
     127        __(movq %imm0,catch_frame.link(%imm2))
     128        __(movq [$]$1,catch_frame.mvflag(%imm2))
     129        __(movq rcontext(tcr.xframe),%imm0)
     130        __(movq %rsp,catch_frame.rsp(%imm2))
     131        __(movq %rbp,catch_frame.rbp(%imm2))
     132        __(movq rcontext(tcr.foreign_sp),%stack_temp)
     133        __(movq %imm1,catch_frame.db_link(%imm2))
     134        __ifndef([WINDOWS])
     135        __(movq %save3,catch_frame._save3(%imm2))
     136        __endif
     137        __(movq %save2,catch_frame._save2(%imm2))
     138        __(movq %save1,catch_frame._save1(%imm2))
     139        __(movq %save0,catch_frame._save0(%imm2))
     140        __(movq %imm0,catch_frame.xframe(%imm2))
     141        __(movq %stack_temp,catch_frame.foreign_sp(%imm2))
     142        __(movq %xfn,catch_frame.pc(%imm2))
     143        __(movq %imm2,rcontext(tcr.catch_top))
    188144])     
    189145
    190146define([nMake_Catch],[
    191147        Allocate_Catch_Frame(%imm2)
    192         movq %rcontext:tcr.catch_top,%imm0
    193         movq %rcontext:tcr.db_link,%imm1
    194         movq %arg_z,catch_frame.catch_tag(%imm2)
    195         movq %imm0,catch_frame.link(%imm2)
    196         lea node_size(%rsp),%imm0
    197         movq [$]$1,catch_frame.mvflag(%imm2)
    198         movq %imm0,catch_frame.rsp(%imm2)
    199         movq %rcontext:tcr.xframe,%imm0
    200         movq %rbp,catch_frame.rbp(%imm2)
    201         movq %rcontext:tcr.foreign_sp,%stack_temp
    202         movq %imm1,catch_frame.db_link(%imm2)
    203         movq %save3,catch_frame._save3(%imm2)
    204         movq %save2,catch_frame._save2(%imm2)
    205         movq %save1,catch_frame._save1(%imm2)
    206         movq %save0,catch_frame._save0(%imm2)
    207         movq %imm0,catch_frame.xframe(%imm2)
    208         movq %stack_temp,catch_frame.foreign_sp(%imm2)
    209         movq %xfn,catch_frame.pc(%imm2)
    210         movq %imm2,%rcontext:tcr.catch_top
     148        __(movq rcontext(tcr.catch_top),%imm0)
     149        __(movq rcontext(tcr.db_link),%imm1)
     150        __(movq %arg_z,catch_frame.catch_tag(%imm2))
     151        __(movq %imm0,catch_frame.link(%imm2))
     152        __(lea node_size(%rsp),%imm0)
     153        __(movq [$]$1,catch_frame.mvflag(%imm2))
     154        __(movq %imm0,catch_frame.rsp(%imm2))
     155        __(movq rcontext(tcr.xframe),%imm0)
     156        __(movq %rbp,catch_frame.rbp(%imm2))
     157        __(movq rcontext(tcr.foreign_sp),%stack_temp)
     158        __(movq %imm1,catch_frame.db_link(%imm2))
     159        __ifndef([WINDOWS])
     160        __(movq %save3,catch_frame._save3(%imm2))
     161        __endif
     162        __(movq %save2,catch_frame._save2(%imm2))
     163        __(movq %save1,catch_frame._save1(%imm2))
     164        __(movq %save0,catch_frame._save0(%imm2))
     165        __(movq %imm0,catch_frame.xframe(%imm2))
     166        __(movq %stack_temp,catch_frame.foreign_sp(%imm2))
     167        __(movq %xfn,catch_frame.pc(%imm2))
     168        __(movq %imm2,rcontext(tcr.catch_top))
    211169])     
    212170               
     
    229187/* to interrupt; the interrupting code has to recognize and possibly  */
    230188/* emulate the instructions in between   */
    231         subq $cons.size-fulltag_cons,%rcontext:tcr.save_allocptr
    232         movq %rcontext:tcr.save_allocptr,%allocptr
    233         rcmpq(%allocptr,%rcontext:tcr.save_allocbase)
    234         jg macro_label(no_trap)
     189        __(subq $cons.size-fulltag_cons,rcontext(tcr.save_allocptr))
     190        __(movq rcontext(tcr.save_allocptr),%allocptr)
     191        __(rcmpq(%allocptr,rcontext(tcr.save_allocbase)))
     192        __(jg macro_label(no_trap))
    235193        uuo_alloc()
    236194macro_label(no_trap):   
    237         andb $~fulltagmask,%rcontext:tcr.save_allocptr
     195        __(andb $~fulltagmask,rcontext(tcr.save_allocptr))
    238196/* Easy to interrupt now that tcr.save_allocptr isn't tagged as a cons    */
    239         movq $2,cons.cdr(%allocptr)
    240         movq $1,cons.car(%allocptr)
     197        __(movq $2,cons.cdr(%allocptr))
     198        __(movq $1,cons.car(%allocptr))
    241199        ifelse($3,[],[],[
    242          movq %allocptr,$3
     200         __(movq %allocptr,$3)
    243201        ])
    244202])
     
    248206
    249207define([Misc_Alloc],[
    250         subq [$]fulltag_misc,%imm1
     208        __(subq [$]fulltag_misc,%imm1)
    251209        Misc_Alloc_Internal($1)
    252210])
     
    257215               
    258216        new_macro_labels()
    259         subq %imm1,%rcontext:tcr.save_allocptr
    260         movq %rcontext:tcr.save_allocptr,%allocptr
    261         rcmpq(%allocptr,%rcontext:tcr.save_allocbase)
    262         jg macro_label(no_trap)
     217        __(subq %imm1,rcontext(tcr.save_allocptr))
     218        __(movq rcontext(tcr.save_allocptr),%allocptr)
     219        __(rcmpq(%allocptr,rcontext(tcr.save_allocbase)))
     220        __(jg macro_label(no_trap))
    263221        uuo_alloc()
    264222macro_label(no_trap):   
    265         movq %imm0,misc_header_offset(%allocptr)
    266         andb $~fulltagmask,%rcontext:tcr.save_allocptr
     223        __(movq %imm0,misc_header_offset(%allocptr))
     224        __(andb $~fulltagmask,rcontext(tcr.save_allocptr))
    267225/* Now that tcr.save_allocptr is untagged, it's easier to be interrupted   */
    268226        ifelse($1,[],[],[
    269          mov %allocptr,$1
     227         __(mov %allocptr,$1)
    270228        ])
    271229])
    272230       
    273231define([Misc_Alloc_Fixed],[
    274         movq [$]$2-fulltag_misc,%imm1
     232        __(movq [$]$2-fulltag_misc,%imm1)
    275233        Misc_Alloc_Internal($1)
    276234])                                     
    277235
    278236define([vrefr],[
    279         mov misc_data_offset+($3<<word_shift)($2),$1
     237        __(mov misc_data_offset+($3<<word_shift)($2),$1)
    280238])     
    281239
    282240define([jump_fn],[
    283         jmpq *%fn
     241        __(jmpq *%fn)
    284242])
    285243                       
    286244define([jump_fname],[
    287         mov symbol.fcell(%fname),%fn
     245        __(mov symbol.fcell(%fname),%fn)
    288246        jump_fn()
    289247])     
    290248       
    291249define([set_nargs],[
    292         movw [$]$1<<fixnumshift,%nargs
    293 ])
     250        ifelse(eval($1>15),1,[
     251        __(movl [$]$1<<fixnumshift,%nargs)
     252        ],[
     253        __(xorl %nargs,%nargs)
     254        ifelse(eval($1),0,[],[
     255        __(addl [$]$1<<fixnumshift,%nargs)
     256        ])])])
     257       
     258
    294259
    295260/* $1 = ndigits.  Assumes 4-byte digits           */
     
    298263
    299264define([_car],[
    300         movq cons.car($1),$2
     265        __(movq cons.car($1),$2)
    301266])     
    302267
    303268define([_rplaca],[
    304         movq $2,cons.car($1)
     269        __(movq $2,cons.car($1))
    305270])     
    306271               
    307272define([_cdr],[
    308         movq cons.cdr($1),$2
     273        __(movq cons.cdr($1),$2)
    309274])
    310275
    311276define([_rplacd],[
    312         movq $2,cons.cdr($1)
     277        __(movq $2,cons.cdr($1))
    313278])     
    314279               
     
    327292define([do_funcall],[
    328293        new_macro_labels()
    329         movb %temp0_b,%imm0_b
    330         andb $fulltagmask,%imm0_b
    331         cmpb $fulltag_symbol,%imm0_b
     294        __(movb %temp0_b,%imm0_b)
     295        __(andb $fulltagmask,%imm0_b)
     296        __(cmpb $fulltag_symbol,%imm0_b)
    332297        /* %fname == %temp0   */
    333         cmovgq %temp0,%fn
     298        __(cmovgq %temp0,%fn)
    334299        jl macro_label(bad)
    335         cmoveq symbol.fcell(%fname),%fn
    336         jmp *%fn
     300        __(cmoveq symbol.fcell(%fname),%fn)
     301        __(jmp *%fn)
    337302macro_label(bad):               
    338303        __(uuo_error_not_callable)
     
    340305
    341306define([getvheader],[
    342         movq misc_header_offset($1),$2
     307        __(movq misc_header_offset($1),$2)
    343308])
    344309
     
    346311/*    both be immediate registers   */
    347312define([header_size],[
    348         movq $1,$2
    349         shr $num_subtag_bits,$2
     313        __(movq $1,$2)
     314        __(shr $num_subtag_bits,$2)
    350315])
    351316
    352317/* $2 (length) is fixnum element-count.   */
    353318define([header_length],[
    354         movq $~255,$2
    355         andq $1,$2
    356         shr $num_subtag_bits-fixnumshift,$2
     319        __(movq $~255,$2)
     320        __(andq $1,$2)
     321        __(shr $num_subtag_bits-fixnumshift,$2)
    357322])
    358323
     
    365330/* $1 = vector, $2 = dest   */
    366331define([vector_length],[                                 
    367         movq $~255,$2
    368         andq misc_header_offset($1),$2
    369         shr $num_subtag_bits-fixnumshift,$2
     332        __(movq $~255,$2)
     333        __(andq misc_header_offset($1),$2)
     334        __(shr $num_subtag_bits-fixnumshift,$2)
    370335])
    371336               
    372337/* GAS/ATT comparison arg order drives me nuts   */
    373338define([rcmpq],[
    374         cmpq $2,$1
     339        __(cmpq $2,$1)
    375340])
    376341
    377342define([rcmpl],[
    378         cmpl $2,$1
     343        __(cmpl $2,$1)
    379344])     
    380345
    381346define([rcmpw],[
    382         cmpw $2,$1
     347        __(cmpw $2,$1)
    383348])     
    384349
    385350define([rcmpb],[
    386         cmpb $2,$1
     351        __(cmpb $2,$1)
    387352])             
    388353
    389354
    390355define([condition_to_boolean],[
    391         movl [$]t_value,$2_l
    392         lea (-t_offset)($2),$3
    393         cmov$1l $2_l,$3_l
     356        __(movl [$]t_value,$2_l)
     357        __(lea (-t_offset)($2),$3)
     358        __(cmov$1l $2_l,$3_l)
    394359])
    395360
    396361define([compare_reg_to_nil],[
    397         cmpb $fulltag_nil,$1_b
     362        __(cmpb $fulltag_nil,$1_b)
    398363])             
    399364       
    400365define([extract_lisptag],[
    401         movzbl $1_b,$2_l
    402         andb [$]tagmask,$2_b
     366        __(movzbl $1_b,$2_l)
     367        __(andb [$]tagmask,$2_b)
    403368])
    404369
    405370                                                               
    406371define([extract_fulltag],[
    407         movzbl $1_b,$2_l
    408         andb [$]fulltagmask,$2_b
     372        __(movzbl $1_b,$2_l)
     373        __(andb [$]fulltagmask,$2_b)
    409374])
    410375
    411376define([extract_subtag],[
    412         movb misc_subtag_offset($1),$2
     377        __(movb misc_subtag_offset($1),$2)
    413378])
    414379
    415380define([extract_typecode],[
    416381        new_macro_labels()
    417         movzbl $1_b,$2_l
    418         andb $tagmask,$2_b
    419         cmpb $tag_misc,$2_b
    420         jne macro_label(done)
    421         movb misc_subtag_offset($1),$2_b
     382        __(movzbl $1_b,$2_l)
     383        __(andb $tagmask,$2_b)
     384        __(cmpb $tag_misc,$2_b)
     385        __(jne macro_label(done))
     386        __(movb misc_subtag_offset($1),$2_b)
    422387macro_label(done):     
    423388])
     
    426391
    427392        define([dnode_align],[
    428         lea ($2+(dnode_size-1))($1),$3
    429         andb $~(dnode_size-1),$3_b
     393        __(lea ($2+(dnode_size-1))($1),$3)
     394        __(andb $~(dnode_size-1),$3_b)
    430395])
    431396       
    432397define([push_argregs],[
    433398        new_macro_labels()
    434         testw %nargs,%nargs
    435         jz macro_label(done)
    436         cmpw [$]2*node_size,%nargs
    437         je macro_label(yz)
    438         jb macro_label(z)
    439         push %arg_x
     399        __(testl %nargs,%nargs)
     400        __(jz macro_label(done))
     401        __(cmpl [$]2*node_size,%nargs)
     402        __(je macro_label(yz))
     403        __(jb macro_label(z))
     404        __(push %arg_x)
    440405macro_label(yz):
    441         push %arg_y
     406        __(push %arg_y)
    442407macro_label(z):
    443         push %arg_z
     408        __(push %arg_z)
    444409macro_label(done):
    445410])     
     
    450415
    451416define([discard_temp_frame],[
    452         movq %rcontext:tcr.save_tsp,$1
    453         movq ($1),$1
    454         movq $1,%rcontext:tcr.save_tsp
    455         movq $1,%rcontext:tcr.next_tsp
     417        __(movq rcontext(tcr.save_tsp),$1)
     418        __(movq ($1),$1)
     419        __(movq $1,rcontext(tcr.save_tsp))
     420        __(movq $1,rcontext(tcr.next_tsp))
    456421
    457422])     
    458423
    459424define([check_pending_enabled_interrupt],[
    460         btrq [$]63,%rcontext:tcr.interrupt_pending
    461         jnc,pt $1
     425        __(btrq [$]63,rcontext(tcr.interrupt_pending))
     426        __(jnc,pt $1)
    462427        interrupt_now()
    463428])
     
    470435define([check_pending_interrupt],[
    471436        new_macro_labels()
    472         movq %rcontext:tcr.tlb_pointer,$1
    473         cmpq [$]0,INTERRUPT_LEVEL_BINDING_INDEX($1)
    474         js,pt macro_label(done)
     437        __(movq rcontext(tcr.tlb_pointer),$1)
     438        __(cmpq [$]0,INTERRUPT_LEVEL_BINDING_INDEX($1))
     439        __(js,pt macro_label(done))
    475440        check_pending_enabled_interrupt(macro_label(done))
    476441macro_label(done):
     
    486451        ifelse($1,[],[
    487452        ],[
    488         movq $1,%rdi
     453        __(movq $1,%rdi)
    489454        ])
    490         movl [$]0x3000003,%eax
    491         syscall
     455        __(movl [$]0x3000003,%eax)
     456        __(syscall)
    492457])
    493458
     
    496461       
    497462define([set_foreign_gs_base],[
    498         set_gs_base([%rcontext:tcr.osid])
     463        set_gs_base([rcontext(tcr.osid)])
    499464])
    500465
     
    503468
    504469define([save_tcr_linear],[
    505         movq %rcontext:tcr.linear,$1
     470        __(movq rcontext(tcr.linear),$1)
    506471])
    507472       
     
    512477/*  branch or (b) immediately follows a conditional branch not taken. */
    513478define([repret],[
    514         .byte 0xf3
    515          ret
     479        __(.byte 0xf3)
     480        __(ret)
    516481])
    517482                               
  • branches/working-0711-perf/ccl/lisp-kernel/x86-spentry64.s

    r9337 r9701  
    558558local_label(misc_ref_bit_vector):
    559559        __(unbox_fixnum(%arg_z,%imm0))
    560         __(movl $63,%imm1_l)
    561         __(andb %imm0_b,%imm1_b)
    562         __(shrq $6,%imm0)
    563         __(btq %imm1,misc_data_offset(%arg_y,%imm0,8))
     560        __(btq %imm0,misc_data_offset(%arg_y))
    564561        __(setc %imm0_b)
    565         __(negb %imm0_b)
    566         __(andl $fixnum_one,%imm0_l)
    567         __(movq %imm0,%arg_z)
     562        __(movzbl %imm0_b,%imm0_l)
     563        __(imull $fixnumone,%imm0_l,%arg_z_l)
    568564        __(ret)
    569565local_label(misc_ref_invalid):
     
    10231019        __(testq $~fixnumone,%arg_z)
    10241020        __(jne local_label(misc_set_bad))
    1025         __(unbox_fixnum(%arg_y,%imm1))
    1026         __(movzbl %imm1_b,%imm0_l)
    1027         __(andb $63,%imm0_b)
    1028         __(shrq $6,%imm1)
     1021        __(unbox_fixnum(%arg_y,%imm0))
    10291022        __(testb %arg_z_b,%arg_z_b)
    10301023        __(je local_label(misc_set_clr_bit))
    10311024local_label(misc_set_set_bit): 
    1032         __(btsq %imm0,misc_data_offset(%arg_x,%imm1,8))
     1025        __(btsq %imm0,misc_data_offset(%arg_x))
    10331026        __(ret)
    10341027local_label(misc_set_clr_bit): 
    1035         __(btrq %imm0,misc_data_offset(%arg_x,%imm1,8))
     1028        __(btrq %imm0,misc_data_offset(%arg_x))
    10361029        __(ret)
    10371030local_label(misc_set_u8):       
     
    11211114        __(cmpq lisp_frame.savera0(%rbp),%temp1)
    11221115        __(je 1f)
    1123         __(testw %nargs,%nargs)
    1124         __(movzwl %nargs,%nargs_l)
     1116        __(testl %nargs,%nargs)
    11251117        __(movl $nil_value,%arg_z_l)
    11261118        __(cmovneq -node_size(%rsp,%nargs_q),%arg_z)
     
    11311123/* actually need to return values ; always need to copy   */
    113211241:      __(leaq 2*node_size(%rbp),%imm1)
    1133         __(movzwl %nargs,%nargs_l)
    11341125        __(movq (%imm1),%ra0)
    11351126        __(addq $node_size,%imm1)
     
    114011312:      __(movq -node_size(%temp0),%temp1)
    11411132        __(subq $node_size,%temp0)
    1142         __(addq $node_size,%imm0)
     1133        __(addl $node_size,%imm0_l)
    11431134        __(movq %temp1,-node_size(%imm1))
    11441135        __(subq $node_size,%imm1)
    1145 3:      __(cmpw %imm0_w,%nargs)
     11363:      __(cmpl %imm0_l,%nargs)  ;
    11461137        __(jne 2b)
    11471138        __(movq %imm1,%rsp)
     
    11761167   double binding of *interrupt-level* out-of-line */
    11771168_spentry(nmkunwind)
    1178         __(movq %rcontext:tcr.tlb_pointer,%arg_x)
     1169        __(movq rcontext(tcr.tlb_pointer),%arg_x)
    11791170        __(movq INTERRUPT_LEVEL_BINDING_INDEX(%arg_x),%arg_y)
    11801171        __(push %arg_y)
    11811172        __(push $INTERRUPT_LEVEL_BINDING_INDEX)
    1182         __(push %rcontext:tcr.db_link)
    1183         __(movq %rsp,%rcontext:tcr.db_link)
     1173        __(push rcontext(tcr.db_link))
     1174        __(movq %rsp,rcontext(tcr.db_link))
    11841175        __(movq $-1<<fixnumshift,INTERRUPT_LEVEL_BINDING_INDEX(%arg_x))
    11851176        __(movq $undefined,%arg_z)
     
    11951186       
    11961187_spentry(throw)
    1197         __(movq %rcontext:tcr.catch_top,%imm1)
     1188        __(movq rcontext(tcr.catch_top),%imm1)
    11981189        __(xorl %imm0_l,%imm0_l)
    1199         __(movzwl %nargs,%nargs_l)
    12001190        __(movq (%rsp,%nargs_q),%temp0) /* temp0 = tag   */
    12011191        __(jmp local_label(_throw_test))
     
    12151205        __(testb $fulltagmask,catch_frame.mvflag(%imm1))
    12161206        __(jne local_label(_throw_multiple))
    1217         __(testw %nargs,%nargs)
     1207        __(testl %nargs,%nargs)
    12181208        __(movl $nil_value,%arg_z_l)
    12191209        __(je local_label(_throw_one_value))
     
    12241214        __(jmp _SPnthrow1value)
    12251215__(tra(local_label(_threw_one_value)))
    1226         __(movq %rcontext:tcr.catch_top,%temp0)
     1216        __(movq rcontext(tcr.catch_top),%temp0)
    12271217        __(movq catch_frame.db_link(%temp0),%imm0)
    1228         __(movq %rcontext:tcr.db_link,%imm1)
     1218        __(movq rcontext(tcr.db_link),%imm1)
    12291219        __(cmpq %imm0,%imm1)
    12301220        __(jz local_label(_threw_one_value_dont_unbind))
     
    12361226        __(movq catch_frame.foreign_sp(%temp0),%imm0)
    12371227        __(movq catch_frame.xframe(%temp0),%imm1)
    1238         __(movq %imm0,%rcontext:tcr.foreign_sp)
    1239         __(movq %imm1,%rcontext:tcr.xframe)
     1228        __(movq %imm0,rcontext(tcr.foreign_sp))
     1229        __(movq %imm1,rcontext(tcr.xframe))
    12401230        __(movq catch_frame.rsp(%temp0),%rsp)
    12411231        __(movq catch_frame.link(%temp0),%imm1)
     
    12431233        __(movq catch_frame._save1(%temp0),%save1)
    12441234        __(movq catch_frame._save2(%temp0),%save2)
     1235        __ifndef([WINDOWS])
    12451236        __(movq catch_frame._save3(%temp0),%save3)
    1246         __(movq %imm1,%rcontext:tcr.catch_top)
     1237        __endif
     1238        __(movq %imm1,rcontext(tcr.catch_top))
    12471239        __(movq catch_frame.pc(%temp0),%ra0)
    12481240        __(lea -(tsp_frame.fixed_overhead+fulltag_misc)(%temp0),%imm1)
    12491241        __(movq (%imm1),%imm1)
    1250         __(movq %imm1,%rcontext:tcr.save_tsp)
    1251         __(movq %imm1,%rcontext:tcr.next_tsp)
     1242        __(movq %imm1,rcontext(tcr.save_tsp))
     1243        __(movq %imm1,rcontext(tcr.next_tsp))
    12521244        __(jmp *%ra0)
    12531245local_label(_throw_multiple):
     
    12551247        __(jmp _SPnthrowvalues)
    12561248__(tra(local_label(_threw_multiple)))
    1257         __(movq %rcontext:tcr.catch_top,%temp0)
     1249        __(movq rcontext(tcr.catch_top),%temp0)
    12581250        __(movq catch_frame.db_link(%temp0),%imm0)
    1259         __(movq %rcontext:tcr.db_link,%imm1)
     1251        __(movq rcontext(tcr.db_link),%imm1)
    12601252        __(cmpq %imm0,%imm1)
    12611253        __(je local_label(_threw_multiple_dont_unbind))
     
    12791271        __(movq catch_frame.rbp(%temp0),%rbp)
    12801272        __(movq catch_frame.foreign_sp(%temp0),%imm0)
    1281         __(movq %imm0,%rcontext:tcr.foreign_sp)       
     1273        __(movq %imm0,rcontext(tcr.foreign_sp))       
    12821274        __(movq catch_frame.xframe(%temp0),%imm0)
    1283         __(movq %imm0,%rcontext:tcr.xframe)
     1275        __(movq %imm0,rcontext(tcr.xframe))
    12841276        __(movq %imm1,%rsp)
    12851277        __(movq catch_frame.link(%temp0),%imm1)         
     
    12871279        __(movq catch_frame._save1(%temp0),%save1)
    12881280        __(movq catch_frame._save2(%temp0),%save2)
     1281        __ifndef([WINDOWS])
    12891282        __(movq catch_frame._save3(%temp0),%save3)
    1290         __(movq %imm1,%rcontext:tcr.catch_top)
     1283        __endif
     1284        __(movq %imm1,rcontext(tcr.catch_top))
    12911285        __(movq catch_frame.pc(%temp0),%ra0)
    12921286        __(lea -(tsp_frame.fixed_overhead+fulltag_misc)(%temp0),%imm1)
    12931287        __(movq (%imm1),%imm1)
    1294         __(movq %imm1,%rcontext:tcr.save_tsp)
    1295         __(movq %imm1,%rcontext:tcr.next_tsp)
     1288        __(movq %imm1,rcontext(tcr.save_tsp))
     1289        __(movq %imm1,rcontext(tcr.next_tsp))
    12961290        __(jmp *%ra0)
    12971291_endsubp(throw)
     
    12991293/* This takes N multiple values atop the vstack.   */
    13001294_spentry(nthrowvalues)
    1301         __(movb $1,%rcontext:tcr.unwinding)
    1302         __(movzwl %nargs,%nargs_l)
     1295        __(movb $1,rcontext(tcr.unwinding))
    13031296local_label(_nthrowv_nextframe):
    13041297        __(subq $fixnumone,%imm0)
    13051298        __(js local_label(_nthrowv_done))
    13061299        __(movd %imm0,%mm1)
    1307         __(movq %rcontext:tcr.catch_top,%temp0)
     1300        __(movq rcontext(tcr.catch_top),%temp0)
    13081301        __(movq catch_frame.link(%temp0),%imm1)
    13091302        __(movq catch_frame.db_link(%temp0),%imm0)
    1310         __(movq %imm1,%rcontext:tcr.catch_top)
    1311         __(cmpq %imm0,%rcontext:tcr.db_link)
     1303        __(movq %imm1,rcontext(tcr.catch_top))
     1304        __(cmpq %imm0,rcontext(tcr.db_link))
    13121305        __(jz local_label(_nthrowv_dont_unbind))
    13131306        __(push %ra0)
     
    13261319        __(jne local_label(_nthrowv_skip))
    13271320        __(movq catch_frame.xframe(%temp0),%save0)
    1328         __(movq %save0,%rcontext:tcr.xframe)
     1321        __(movq %save0,rcontext(tcr.xframe))
    13291322        __(leaq (%rsp,%nargs_q),%save1)
    13301323        __(movq catch_frame.rsp(%temp0),%save2)
     
    13401333        __(jns local_label(_nthrowv_push_loop))
    13411334        __(movq catch_frame.xframe(%temp0),%save0)
    1342         __(movq %save0,%rcontext:tcr.xframe)
     1335        __(movq %save0,rcontext(tcr.xframe))
    13431336        __(movq %save2,%rsp)
    13441337        __(movq catch_frame.rbp(%temp0),%rbp)
     1338        __ifndef([WINDOWS])
    13451339        __(movq catch_frame._save3(%temp0),%save3)
     1340        __endif
    13461341        __(movq catch_frame._save2(%temp0),%save2)
    13471342        __(movq catch_frame._save1(%temp0),%save1)
    13481343        __(movq catch_frame._save0(%temp0),%save0)
    13491344        __(movq catch_frame.foreign_sp(%temp0),%stack_temp)
    1350         __(movq %stack_temp,%rcontext:tcr.foreign_sp)       
     1345        __(movq %stack_temp,rcontext(tcr.foreign_sp))       
    13511346local_label(_nthrowv_skip):     
    13521347        __(movq -(tsp_frame.fixed_overhead+fulltag_misc)(%temp0),%imm1)
    1353         __(movq %imm1,%rcontext:tcr.save_tsp)       
    1354         __(movq %imm1,%rcontext:tcr.next_tsp)
     1348        __(movq %imm1,rcontext(tcr.save_tsp))       
     1349        __(movq %imm1,rcontext(tcr.next_tsp))
    13551350        __(movd %mm1,%imm0)
    13561351        __(jmp local_label(_nthrowv_nextframe))
     
    13631358        __(push catch_frame._save1(%temp0))
    13641359        __(push catch_frame._save2(%temp0))
     1360        __ifndef([WINDOWS])
    13651361        __(push catch_frame._save3(%temp0))
     1362        __endif
    13661363        __(push catch_frame.pc(%temp0))
    13671364        __(movq catch_frame.rbp(%temp0),%rbp)
    13681365        __(movq catch_frame.xframe(%temp0),%stack_temp)
    13691366        __(movq catch_frame.rsp(%temp0),%arg_x)
    1370         __(movq %stack_temp,%rcontext:tcr.xframe)
     1367        __(movq %stack_temp,rcontext(tcr.xframe))
    13711368        __(movq catch_frame.foreign_sp(%temp0),%stack_temp)
    1372         __(movq %stack_temp,%rcontext:tcr.foreign_sp)       
     1369        __(movq %stack_temp,rcontext(tcr.foreign_sp))       
    13731370        /* Discard the catch frame, so we can build a temp frame   */
    13741371        __(movq -(tsp_frame.fixed_overhead+fulltag_misc)(%temp0),%imm1)
    1375         __(movq %imm1,%rcontext:tcr.save_tsp)
    1376         __(movq %imm1,%rcontext:tcr.next_tsp)
     1372        __(movq %imm1,rcontext(tcr.save_tsp))
     1373        __(movq %imm1,rcontext(tcr.next_tsp))
    13771374        /* tsp overhead, nargs, throw count, ra0   */
    13781375        __(dnode_align(%nargs_q,(tsp_frame.fixed_overhead+(3*node_size)),%imm0))
     
    13901387        __(addq $node_size,%imm1)
    13911388local_label(_nthrowv_tpushtest):
    1392         __(subw $node_size,%nargs)
     1389        __(subl $node_size,%nargs)
    13931390        __(jns local_label(_nthrowv_tpushloop))
    13941391        __(pop %xfn)
     1392        __ifndef([WINDOWS])
    13951393        __(pop %save3)
     1394        __endif
    13961395        __(pop %save2)
    13971396        __(pop %save1)
     
    14011400        __(leaq local_label(_nthrowv_called_cleanup)(%rip),%ra0)
    14021401        __(push %ra0)
    1403         __(movb $0,%rcontext:tcr.unwinding)
     1402        __(movb $0,rcontext(tcr.unwinding))
    14041403        __(jmp *%xfn)
    14051404__(tra(local_label(_nthrowv_called_cleanup)))
    14061405
    1407         __(movb $1,%rcontext:tcr.unwinding)
    1408         __(movq %rcontext:tcr.save_tsp,%imm1)
     1406        __(movb $1,rcontext(tcr.unwinding))
     1407        __(movq rcontext(tcr.save_tsp),%imm1)
    14091408        __(movq tsp_frame.data_offset+(0*node_size)(%imm1),%nargs_q)
    14101409        __(movq tsp_frame.data_offset+(1*node_size)(%imm1),%ra0)
     
    14191418        __(subq $node_size,%imm0)
    14201419        __(jns local_label(_nthrowv_tpoploop))
    1421         __(movq %rcontext:tcr.save_tsp,%imm1)
     1420        __(movq rcontext(tcr.save_tsp),%imm1)
    14221421        __(movq (%imm1),%imm1)
    1423         __(movq %imm1,%rcontext:tcr.save_tsp)
    1424         __(movq %imm1,%rcontext:tcr.next_tsp)
     1422        __(movq %imm1,rcontext(tcr.save_tsp))
     1423        __(movq %imm1,rcontext(tcr.next_tsp))
    14251424        __(movd %mm1,%imm0)
    14261425        __(jmp local_label(_nthrowv_nextframe))
    14271426local_label(_nthrowv_done):
    1428         __(movb $0,%rcontext:tcr.unwinding)
     1427        __(movb $0,rcontext(tcr.unwinding))
    14291428        __(check_pending_interrupt(%imm0))
    14301429local_label(_nthrowv_return):   
     
    14371436       
    14381437_spentry(nthrow1value)
    1439         __(movb $1,%rcontext:tcr.unwinding)
    1440         __(movzwl %nargs,%nargs_l)
     1438        __(movb $1,rcontext(tcr.unwinding))
    14411439local_label(_nthrow1v_nextframe):
    14421440        __(subq $fixnumone,%imm0)
    14431441        __(js local_label(_nthrow1v_done))
    14441442        __(movd %imm0,%mm1)
    1445         __(movq %rcontext:tcr.catch_top,%temp0)
     1443        __(movq rcontext(tcr.catch_top),%temp0)
    14461444        __(movq catch_frame.link(%temp0),%imm1)
    14471445        __(movq catch_frame.db_link(%temp0),%imm0)
    1448         __(movq %imm1,%rcontext:tcr.catch_top)
    1449         __(cmpq %imm0,%rcontext:tcr.db_link)
     1446        __(movq %imm1,rcontext(tcr.catch_top))
     1447        __(cmpq %imm0,rcontext(tcr.db_link))
    14501448        __(jz local_label(_nthrow1v_dont_unbind))
    14511449        __(push %ra0)
     
    14641462        __(jne local_label(_nthrow1v_skip))
    14651463        __(movq catch_frame.xframe(%temp0),%save0)
    1466         __(movq %save0,%rcontext:tcr.xframe)
     1464        __(movq %save0,rcontext(tcr.xframe))
    14671465        __(leaq (%rsp,%nargs_q),%save1)
    14681466        __(movq catch_frame.xframe(%temp0),%save0)
    1469         __(movq %save0,%rcontext:tcr.xframe)
     1467        __(movq %save0,rcontext(tcr.xframe))
    14701468        __(movq catch_frame.rsp(%temp0),%rsp)
    14711469        __(movq catch_frame.rbp(%temp0),%rbp)
     1470        __ifndef([WINDOWS])
    14721471        __(movq catch_frame._save3(%temp0),%save3)
     1472        __endif
    14731473        __(movq catch_frame._save2(%temp0),%save2)
    14741474        __(movq catch_frame._save1(%temp0),%save1)
    14751475        __(movq catch_frame._save0(%temp0),%save0)
    14761476        __(movq catch_frame.foreign_sp(%temp0),%stack_temp)
    1477         __(movq %stack_temp,%rcontext:tcr.foreign_sp)       
     1477        __(movq %stack_temp,rcontext(tcr.foreign_sp))       
    14781478local_label(_nthrow1v_skip):   
    14791479        __(movq -(tsp_frame.fixed_overhead+fulltag_misc)(%temp0),%imm1)
    1480         __(movq %imm1,%rcontext:tcr.save_tsp)
    1481         __(movq %imm1,%rcontext:tcr.next_tsp)       
     1480        __(movq %imm1,rcontext(tcr.save_tsp))
     1481        __(movq %imm1,rcontext(tcr.next_tsp))       
    14821482        __(movd %mm1,%imm0)
    14831483        __(jmp local_label(_nthrow1v_nextframe))
     
    14881488       
    14891489        __(movq catch_frame.xframe(%temp0),%save0)
    1490         __(movq %save0,%rcontext:tcr.xframe)
     1490        __(movq %save0,rcontext(tcr.xframe))
    14911491        __(movq catch_frame._save0(%temp0),%save0)
    14921492        __(movq catch_frame._save1(%temp0),%save1)
    14931493        __(movq catch_frame._save2(%temp0),%save2)
     1494        __ifndef([WINDOWS])
    14941495        __(movq catch_frame._save3(%temp0),%save3)
     1496        __endif
    14951497        __(movq catch_frame.pc(%temp0),%xfn)
    14961498        __(movq catch_frame.rbp(%temp0),%rbp)
    14971499        __(movq catch_frame.rsp(%temp0),%rsp)
    14981500        __(movq catch_frame.foreign_sp(%temp0),%stack_temp)
    1499         __(movq %stack_temp,%rcontext:tcr.foreign_sp)       
     1501        __(movq %stack_temp,rcontext(tcr.foreign_sp))       
    15001502        /* Discard the catch frame, so we can build a temp frame   */
    15011503        __(movq -(tsp_frame.fixed_overhead+fulltag_misc)(%temp0),%imm1)
    1502         __(movq %imm1,%rcontext:tcr.save_tsp)
    1503         __(movq %imm1,%rcontext:tcr.next_tsp)       
     1504        __(movq %imm1,rcontext(tcr.save_tsp))
     1505        __(movq %imm1,rcontext(tcr.next_tsp))       
    15041506        __(TSP_Alloc_Fixed((3*node_size),%imm1))
    15051507        __(addq $tsp_frame.fixed_overhead,%imm1)
     
    15091511/* Ready to call cleanup code. set up tra, jmp to %xfn   */
    15101512        __(leaq local_label(_nthrow1v_called_cleanup)(%rip),%ra0)
    1511         __(movb $0,%rcontext:tcr.unwinding)
     1513        __(movb $0,rcontext(tcr.unwinding))
    15121514        __(push %ra0)
    15131515        __(jmp *%xfn)
    15141516__(tra(local_label(_nthrow1v_called_cleanup)))
    15151517
    1516         __(movb $1,%rcontext:tcr.unwinding)
    1517         __(movq %rcontext:tcr.save_tsp,%imm1)
     1518        __(movb $1,rcontext(tcr.unwinding))
     1519        __(movq rcontext(tcr.save_tsp),%imm1)
    15181520        __(movq tsp_frame.data_offset+(0*node_size)(%imm1),%ra0)
    15191521        __(movq tsp_frame.data_offset+(1*node_size)(%imm1),%mm1)
     
    15211523
    15221524        __(movq (%imm1),%imm1)
    1523         __(movq %imm1,%rcontext:tcr.save_tsp)
    1524         __(movq %imm1,%rcontext:tcr.next_tsp)       
     1525        __(movq %imm1,rcontext(tcr.save_tsp))
     1526        __(movq %imm1,rcontext(tcr.next_tsp))       
    15251527        __(movd %mm1,%imm0)
    15261528        __(jmp local_label(_nthrow1v_nextframe))
    15271529local_label(_nthrow1v_done):
    1528         __(movb $0,%rcontext:tcr.unwinding)
     1530        __(movb $0,rcontext(tcr.unwinding))
    15291531        __(check_pending_interrupt(%imm0))
    15301532local_label(_nthrow1v_return): 
     
    15371539_spentry(bind)
    15381540        __(movq symbol.binding_index(%arg_y),%temp0)
    1539         __(cmpq %rcontext:tcr.tlb_limit,%temp0)
     1541        __(cmpq rcontext(tcr.tlb_limit),%temp0)
    15401542        __(jb,pt 0f)
    15411543        __(push %temp0)
     
    154315450:      __(testq %temp0,%temp0)
    15441546        __(jz 9f)
    1545         __(movq %rcontext:tcr.tlb_pointer,%temp1)
     1547        __(movq rcontext(tcr.tlb_pointer),%temp1)
    15461548        __(push (%temp1,%temp0))
    15471549        __(push %temp0)
    1548         __(push %rcontext:tcr.db_link)
    1549         __(movq %rsp,%rcontext:tcr.db_link)
     1550        __(push rcontext(tcr.db_link))
     1551        __(movq %rsp,rcontext(tcr.db_link))
    15501552        __(movq %arg_z,(%temp1,%temp0))
    15511553        __(jmp *%ra0)
     
    15621564_spentry(bind_self)
    15631565        __(movq symbol.binding_index(%arg_z),%temp0)
    1564         __(cmpq %rcontext:tcr.tlb_limit,%temp0)
     1566        __(cmpq rcontext(tcr.tlb_limit),%temp0)
    15651567        __(jb,pt 0f)
    15661568        __(push %temp0)
     
    156815700:      __(testq %temp0,%temp0)
    15691571        __(jz 9f)
    1570         __(movq %rcontext:tcr.tlb_pointer,%temp1)
     1572        __(movq rcontext(tcr.tlb_pointer),%temp1)
    15711573        __(cmpb $no_thread_local_binding_marker,(%temp0,%temp1))
    15721574        __(jz 2f)
    15731575        __(push (%temp1,%temp0))
    15741576        __(push %temp0)
    1575         __(push %rcontext:tcr.db_link)
    1576         __(movq %rsp,%rcontext:tcr.db_link)
     1577        __(push rcontext(tcr.db_link))
     1578        __(movq %rsp,rcontext(tcr.db_link))
    15771579        __(jmp *%ra0)
    157815802:      __(movq symbol.vcell(%arg_z),%arg_y)
    15791581        __(push (%temp1,%temp0))
    15801582        __(push %temp0)
    1581         __(push %rcontext:tcr.db_link)
     1583        __(push rcontext(tcr.db_link))
    15821584        __(movq %arg_y,(%temp1,%temp0))
    1583         __(movq %rsp,%rcontext:tcr.db_link)
     1585        __(movq %rsp,rcontext(tcr.db_link))
    15841586        __(jmp *%ra0)
    158515879:      __(movq $XSYMNOBIND,%arg_y)
     
    15911593_spentry(bind_nil)
    15921594        __(movq symbol.binding_index(%arg_z),%temp0)
    1593         __(cmpq %rcontext:tcr.tlb_limit,%temp0)
     1595        __(cmpq rcontext(tcr.tlb_limit),%temp0)
    15941596        __(jb,pt 0f)
    15951597        __(push %temp0)
     
    159715990:      __(testq %temp0,%temp0)
    15981600        __(jz 9f)
    1599         __(movq %rcontext:tcr.tlb_pointer,%temp1)
     1601        __(movq rcontext(tcr.tlb_pointer),%temp1)
    16001602        __(push (%temp1,%temp0))
    16011603        __(push %temp0)
    1602         __(push %rcontext:tcr.db_link)
    1603         __(movq %rsp,%rcontext:tcr.db_link)
    1604         __(movq $nil_value,(%temp0,%temp1))
     1604        __(push rcontext(tcr.db_link))
     1605        __(movq %rsp,rcontext(tcr.db_link))
     1606        __(movq $nil_value,(%temp1,%temp0))
    16051607        __(jmp *%ra0)
    160616089:      __(movq $XSYMNOBIND,%arg_y)
     
    16121614_spentry(bind_self_boundp_check)
    16131615        __(movq symbol.binding_index(%arg_z),%temp0)
    1614         __(cmpq %rcontext:tcr.tlb_limit,%temp0)
     1616        __(cmpq rcontext(tcr.tlb_limit),%temp0)
    16151617        __(jb,pt 0f)
    16161618        __(push %temp0)
     
    161816200:      __(testq %temp0,%temp0)
    16191621        __(jz 9f)
    1620         __(movq %rcontext:tcr.tlb_pointer,%temp1)
     1622        __(movq rcontext(tcr.tlb_pointer),%temp1)
    16211623        __(cmpb $no_thread_local_binding_marker,(%temp1,%temp0))
    16221624        __(je 2f)
     
    16251627        __(push (%temp1,%temp0))
    16261628        __(push %temp0)
    1627         __(push %rcontext:tcr.db_link)
    1628         __(movq %rsp,%rcontext:tcr.db_link)
     1629        __(push rcontext(tcr.db_link))
     1630        __(movq %rsp,rcontext(tcr.db_link))
    16291631        __(jmp *%ra0)
    163016322:      __(movq symbol.vcell(%arg_z),%arg_y)
     
    16331635        __(push (%temp1,%temp0))
    16341636        __(push %temp0)
    1635         __(push %rcontext:tcr.db_link)
    1636         __(movq %rsp,%rcontext:tcr.db_link)
     1637        __(push rcontext(tcr.db_link))
     1638        __(movq %rsp,rcontext(tcr.db_link))
    16371639        __(movq %arg_y,(%temp1,%temp0))
    16381640        __(jmp *%ra0)
     
    16481650_spentry(conslist)
    16491651        __(movl $nil_value,%arg_z_l)
    1650         __(testw %nargs,%nargs)
     1652        __(testl %nargs,%nargs)
    16511653        __(jmp 2f)
    165216541:      __(pop %arg_y)
    16531655        __(Cons(%arg_y,%arg_z,%arg_z))
    1654         __(subw $node_size,%nargs)
     1656        __(subl $node_size,%nargs)
    165516572:      __(jnz 1b)
    16561658        __(jmp *%ra0)           
     
    16611663       
    16621664_spentry(conslist_star)
    1663         __(testw %nargs,%nargs)
     1665        __(testl %nargs,%nargs)
    16641666        __(jmp 2f)
    166516671:      __(pop %arg_y)
    16661668        __(Cons(%arg_y,%arg_z,%arg_z))
    1667         __(subw $node_size,%nargs)
     1669        __(subl $node_size,%nargs)
    166816702:      __(jnz 1b)
    16691671        __(jmp *%ra0)           
     
    16731675/* doesn't get confused.   */
    16741676_spentry(stkconslist)
    1675         __(movzwl %nargs,%nargs_l)
    16761677        __(movq %nargs_q,%imm1)
    16771678        __(addq %imm1,%imm1)
     
    16801681        __(TSP_Alloc_Var(%imm1,%imm0))
    16811682        __(addq $fulltag_cons,%imm0)
    1682         __(testw %nargs,%nargs)
     1683        __(testl %nargs,%nargs)
    16831684        __(jmp 2f)
    168416851:      __(pop %temp0)
     
    16871688        __(movq %imm0,%arg_z)
    16881689        __(add $cons.size,%imm0)
    1689         __(subw $node_size,%nargs)
     1690        __(subl $node_size,%nargs)
    169016912:      __(jne 1b)
    16911692        __(jmp *%ra0)
     
    16961697       
    16971698_spentry(stkconslist_star)
    1698         __(movzwl %nargs,%nargs_l)
    16991699        __(movq %nargs_q,%imm1)
    17001700        __(addq %imm1,%imm1)
     
    17021702        __(TSP_Alloc_Var(%imm1,%imm0))
    17031703        __(addq $fulltag_cons,%imm0)
    1704         __(testw %nargs,%nargs)
     1704        __(testl %nargs,%nargs)
    17051705        __(jmp 2f)
    170617061:      __(pop %temp0)
     
    17091709        __(movq %imm0,%arg_z)
    17101710        __(addq $cons.size,%imm0)
    1711         __(subw $node_size,%nargs)
     1711        __(subl $node_size,%nargs)
    171217122:      __(jne 1b)
    17131713        __(jmp *%ra0)
     
    17181718       
    17191719_spentry(mkstackv)
    1720         __(movzwl %nargs,%nargs_l)
    17211720        __(dnode_align(%nargs_q,tsp_frame.fixed_overhead+node_size,%imm1))
    17221721        __(TSP_Alloc_Var(%imm1,%temp0))
    1723         __(movl %nargs_l,%imm0_l)
     1722        __(movl %nargs,%imm0_l)
    17241723        __(shlq $(num_subtag_bits-fixnumshift),%imm0)
    17251724        __(movb $subtag_simple_vector,%imm0_b)
    17261725        __(movq %imm0,(%temp0))
    17271726        __(leaq fulltag_misc(%temp0),%arg_z)
    1728         __(testw %nargs,%nargs)
     1727        __(testl %nargs,%nargs)
    17291728        __(leaq misc_data_offset(%arg_z,%nargs_q),%imm1)
    17301729        __(jmp 2f)
    173117301:      __(pop -node_size(%imm1))
    1732         __(subw $node_size,%nargs)
     1731        __(subl $node_size,%nargs)
    17331732        __(leaq -node_size(%imm1),%imm1)
    173417332:      __(jne 1b)
     
    19661965        __(TSP_Alloc_Var(%imm1,%temp0))
    19671966        __(movq %imm0,(%temp0))
    1968         __(movq %rcontext:tcr.db_link,%temp1)
     1967        __(movq rcontext(tcr.db_link),%temp1)
    196919683:      __(movl $unbound_marker,%temp0_l)
    19701969        __(compare_reg_to_nil(%arg_z))
     
    19741973        __(_cdr(%arg_y,%arg_y))
    19751974        __(movq symbol.binding_index(%arg_x),%arg_x)
    1976         __(cmp %rcontext:tcr.tlb_limit,%arg_x)
     1975        __(cmp rcontext(tcr.tlb_limit),%arg_x)
    19771976        __(jb,pt 4f)
    19781977        __(push %arg_x)
    19791978        __(tlb_too_small())
    1980 4:      __(movq %rcontext:tcr.tlb_pointer,%imm0)
     19794:      __(movq rcontext(tcr.tlb_pointer),%imm0)
    19811980        __(subq $binding.size,%imm1)
    19821981        __(compare_reg_to_nil(%arg_y))
     
    19881987        __(movq %imm1,%temp1)
    19891988        __(jne 3b)
    1990         __(movq %temp1,%rcontext:tcr.db_link)
     1989        __(movq %temp1,rcontext(tcr.db_link))
    19911990        __(ret)
    19921991_endsubp(progvsave)
     
    20422041        __(cmpq $tstack_alloc_limit,%imm1)
    20432042        __(ja local_label(stack_misc_alloc_heap_alloc_ivector))
    2044         __(movq %rcontext:tcr.foreign_sp,%stack_temp)
     2043        __(movq rcontext(tcr.foreign_sp),%stack_temp)
    20452044        __(movd %stack_temp,%temp1)
    2046         __(subq %imm1,%rcontext:tcr.foreign_sp)
    2047         __(movq %rcontext:tcr.foreign_sp,%temp0)
     2045        __(subq %imm1,rcontext(tcr.foreign_sp))
     2046        __(movq rcontext(tcr.foreign_sp),%temp0)
    204820470:      __(movapd %fpzero,-dnode_size(%temp1))
    20492048        __(subq $dnode_size,%temp1)
     
    20562055        __(ret)
    20572056local_label(stack_misc_alloc_heap_alloc_ivector):
    2058         __(movq %rcontext:tcr.foreign_sp,%imm1)
    2059         __(subq $dnode_size,%rcontext:tcr.foreign_sp)
    2060         __(movq %rcontext:tcr.foreign_sp,%imm0)
     2057        __(movq rcontext(tcr.foreign_sp),%imm1)
     2058        __(subq $dnode_size,rcontext(tcr.foreign_sp))
     2059        __(movq rcontext(tcr.foreign_sp),%imm0)
    20612060        __(movq %imm1,(%imm0))
    20622061        __(jmp _SPmisc_alloc)   
     
    20832082/* objects.   */
    20842083_spentry(gvector)
    2085         __(movzwl %nargs,%nargs_l)     
    2086         __(subl $node_size,%nargs_l)
     2084        __(subl $node_size,%nargs)
    20872085        __(movq (%rsp,%nargs_q),%imm0)  /* boxed subtype   */
    20882086        __(sarq $fixnumshift,%imm0)
     
    21162114        __(ref_global(ret1val_addr,%imm1))
    21172115        __(cmpq %imm1,%ra0)
    2118         __(movzwl %nargs,%nargs_l)
    21192116        __(movl $nil_value,%arg_z_l)
    21202117        __(je 0f)
    2121         __(testw %nargs,%nargs)
     2118        __(testl %nargs,%nargs)
    21222119        __(cmovneq -node_size(%rsp,%nargs_q),%arg_z)
    21232120        __(movq %temp0,%rsp)
     
    21522149        __(push_argregs())
    21532150        __(movq %next_method_context,%arg_y)
    2154         __(movzwl %nargs,%nargs_l)
    2155         __(movl %nargs_l,%imm1_l)
     2151