Changeset 15755


Ignore:
Timestamp:
Mar 6, 2013, 8:42:50 PM (6 years ago)
Author:
gb
Message:

Recent changes from trunk.

Location:
release/1.9/source
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • release/1.9/source/level-0/l0-misc.lisp

    r15606 r15755  
    758758         (setf (%get-natural ptr target::lockptr.avail) 0
    759759               (%get-natural ptr target::lockptr.waiting) 0)
    760          (decf pending)
    761          (if (> pending 0)
    762            (setf (%get-natural ptr target::lockptr.waiting) pending))
    763760         (setf (%get-ptr spin) (%null-ptr))
    764          (if (>= pending 0)
     761         (dotimes (i pending)
    765762           (%signal-semaphore-ptr signal)))))
    766763    nil))
  • release/1.9/source/level-1/l1-files.lisp

    r15606 r15755  
    8282
    8383(defun native-translated-namestring (path)
    84   (let ((name (translated-namestring path)))
     84  (let ((name (let ((*default-pathname-defaults* #P""))
     85                (translated-namestring path))))
    8586    ;; Check that no quoted /'s
    8687    (when (%path-mem-last-quoted "/" name)
  • release/1.9/source/lisp-kernel/arm-exceptions.c

    r15470 r15755  
    15981598  egc_store_node_conditional,
    15991599  egc_store_node_conditional_test,
    1600   egc_set_hash_key,
    1601   egc_gvset,
    1602   egc_rplaca,
    1603   egc_rplacd,
     1600  egc_set_hash_key, egc_set_hash_key_did_store,
     1601  egc_gvset, egc_gvset_did_store,
     1602  egc_rplaca, egc_rplaca_did_store,
     1603  egc_rplacd, egc_rplacd_did_store,
    16041604  egc_set_hash_key_conditional,
    16051605  egc_set_hash_key_conditional_test,
     
    16251625    LispObj *ea = 0, val = 0, root = 0;
    16261626    bitvector refbits = (bitvector)(lisp_global(REFBITS));
    1627     Boolean need_store = true, need_check_memo = true, need_memoize_root = false;
     1627    Boolean need_check_memo = true, need_memoize_root = false;
    16281628
    16291629    if (program_counter >= &egc_set_hash_key_conditional) {
     
    16331633        return;
    16341634      }
    1635       need_store = false;
    16361635      root = xpGPR(xp,arg_x);
    16371636      ea = (LispObj *) (root+xpGPR(xp,arg_y)+misc_data_offset);
     
    16471646      ea = (LispObj*)(xpGPR(xp,arg_x) + xpGPR(xp,imm0));
    16481647      xpGPR(xp,arg_z) = t_value;
    1649       need_store = false;
    16501648    } else if (program_counter >= &egc_set_hash_key) {
     1649      if (program_counter < &egc_set_hash_key_did_store) {
     1650        return;
     1651      }
    16511652      root = xpGPR(xp,arg_x);
    16521653      val = xpGPR(xp,arg_z);
     
    16541655      need_memoize_root = true;
    16551656    } else if (program_counter >= &egc_gvset) {
     1657      if (program_counter < &egc_gvset_did_store) {
     1658        return;
     1659      }
    16561660      ea = (LispObj *) (xpGPR(xp,arg_x)+xpGPR(xp,arg_y)+misc_data_offset);
    16571661      val = xpGPR(xp,arg_z);
    16581662    } else if (program_counter >= &egc_rplacd) {
     1663      if (program_counter < &egc_rplacd_did_store) {
     1664        return;
     1665      }
    16591666      ea = (LispObj *) untag(xpGPR(xp,arg_y));
    16601667      val = xpGPR(xp,arg_z);
    16611668    } else {                      /* egc_rplaca */
     1669      if (program_counter < &egc_rplaca_did_store) {
     1670        return;
     1671      }
    16621672      ea =  ((LispObj *) untag(xpGPR(xp,arg_y)))+1;
    16631673      val = xpGPR(xp,arg_z);
    1664     }
    1665     if (need_store) {
    1666       *ea = val;
    16671674    }
    16681675    if (need_check_memo) {
  • release/1.9/source/lisp-kernel/arm-spentry.s

    r15706 r15755  
    742742
    743743        .globl C(egc_write_barrier_start)
     744        .globl C(egc_rplaca_did_store)
    744745_spentry(rplaca)
    745746C(egc_write_barrier_start):     
    746747        __(cmp arg_z,arg_y)
    747748        __(_rplaca(arg_y,arg_z))
     749C(egc_rplaca_did_store):               
    748750        __(bxlo lr)
    749751        __(ref_global(temp0,ref_base))
     
    771773
    772774        .globl C(egc_rplacd)
     775        .globl C(egc_rplacd_did_store)
    773776_spentry(rplacd)
    774777C(egc_rplacd):
    775778        __(cmp arg_z,arg_y)
    776779        __(_rplacd(arg_y,arg_z))
     780C(egc_rplacd_did_store):       
    777781        __(bxlo lr)
    778782        __(ref_global(temp0,ref_base))
     
    802806
    803807        .globl C(egc_gvset)
     808        .globl C(egc_gvset_did_store)
    804809_spentry(gvset)
    805810C(egc_gvset):
     
    807812        __(add imm0,arg_y,#misc_data_offset)
    808813        __(str arg_z,[arg_x,imm0])
     814C(egc_gvset_did_store):     
    809815        __(bxlo lr)               
    810816        __(add imm0,imm0,arg_x)
     
    835841/* the store, record the address of the hash-table vector in the refmap,  */
    836842/* as well. */
    837         .globl C(egc_set_hash_key)       
     843        .globl C(egc_set_hash_key)
     844        .globl C(egc_set_hash_key_did_store)
    838845_spentry(set_hash_key)
    839846C(egc_set_hash_key):
     
    841848        __(add imm0,arg_y,#misc_data_offset)
    842849        __(str arg_z,[arg_x,imm0])
     850C(egc_set_hash_key_did_store):         
    843851        __(bxlo lr)
    844852        __(add imm0,imm0,arg_x)
  • release/1.9/source/lisp-kernel/ppc-exceptions.c

    r15470 r15755  
    19211921  egc_store_node_conditional,
    19221922  egc_store_node_conditional_test,
    1923   egc_set_hash_key,
    1924   egc_gvset,
    1925   egc_rplaca,
    1926   egc_rplacd,
     1923  egc_set_hash_key, egc_set_hash_key_did_store,
     1924  egc_gvset, egc_gvset_did_store,
     1925  egc_rplaca, egc_rplaca_did_store,
     1926  egc_rplacd, egc_rplacd_did_store,
    19271927  egc_set_hash_key_conditional,
    19281928  egc_set_hash_key_conditional_test;
     
    19461946    LispObj *ea = 0, val = 0, root = 0;
    19471947    bitvector refbits = (bitvector)(lisp_global(REFBITS));
    1948     Boolean need_store = true, need_check_memo = true, need_memoize_root = false;
     1948    Boolean need_check_memo = true, need_memoize_root = false;
    19491949
    19501950    if (program_counter >= &egc_set_hash_key_conditional) {
     
    19541954        return;
    19551955      }
    1956       need_store = false;
    19571956      root = xpGPR(xp,arg_x);
    19581957      ea = (LispObj *) (root+xpGPR(xp,arg_y)+misc_data_offset);
     
    19681967      ea = (LispObj*)(xpGPR(xp,arg_x) + xpGPR(xp,imm4));
    19691968      xpGPR(xp,arg_z) = t_value;
    1970       need_store = false;
    19711969    } else if (program_counter >= &egc_set_hash_key) {
     1970      if (program_counter < &egc_set_hash_key_did_store) {
     1971        return;
     1972      }
    19721973      root = xpGPR(xp,arg_x);
    19731974      val = xpGPR(xp,arg_z);
     
    19751976      need_memoize_root = true;
    19761977    } else if (program_counter >= &egc_gvset) {
     1978      if (program_counter < &egc_gvset_did_store) {
     1979        return;
     1980      }
    19771981      ea = (LispObj *) (xpGPR(xp,arg_x)+xpGPR(xp,arg_y)+misc_data_offset);
    19781982      val = xpGPR(xp,arg_z);
    19791983    } else if (program_counter >= &egc_rplacd) {
     1984      if (program_counter < &egc_rplacd_did_store) {
     1985        return;
     1986      }
    19801987      ea = (LispObj *) untag(xpGPR(xp,arg_y));
    19811988      val = xpGPR(xp,arg_z);
    19821989    } else {                      /* egc_rplaca */
     1990      if (program_counter < &egc_rplaca_did_store) {
     1991        return;
     1992      }
    19831993      ea =  ((LispObj *) untag(xpGPR(xp,arg_y)))+1;
    19841994      val = xpGPR(xp,arg_z);
    1985     }
    1986     if (need_store) {
    1987       *ea = val;
    19881995    }
    19891996    if (need_check_memo) {
  • release/1.9/source/lisp-kernel/ppc-spentry.s

    r15706 r15755  
    464464/* For RPLACA and RPLACD, things are fairly simple: regardless of where we  */
    465465/* are in the function, we can do the store (even if it's already been done)  */
     466/* Wrong: we generally only want to do it once, at most .... */       
    466467/* and calculate whether or not we need to set the bit out-of-line.  (Actually */
    467468/* setting the bit needs to be done atomically, unless we're sure that other */
     
    470471       
    471472        .globl C(egc_write_barrier_start)
     473        .globl C(egc_rplaca_did_store)
    472474_spentry(rplaca)
    473475C(egc_write_barrier_start):
    474476        __(cmplr(cr2,arg_z,arg_y))
    475477        __(_rplaca(arg_y,arg_z))
     478C(egc_rplaca_did_store):               
    476479        __(blelr cr2)
    477480        __(ref_global(imm2,ref_base))
     
    498501
    499502        .globl C(egc_rplacd)
     503        .globl C(egc_rplacd_did_store)
    500504_spentry(rplacd)
    501505C(egc_rplacd):
    502506        __(cmplr(cr2,arg_z,arg_y))
    503507        __(_rplacd(arg_y,arg_z))
     508C(egc_rplacd_did_store):       
    504509        __(blelr cr2)
    505510        __(ref_global(imm2,ref_base))
     
    528533
    529534        .globl C(egc_gvset)
     535        .globl C(egc_gvset_did_store)
    530536_spentry(gvset)
    531537C(egc_gvset):
     
    533539        __(la imm0,misc_data_offset(arg_y))
    534540        __(strx(arg_z,arg_x,imm0))
     541C(egc_gvset_did_store):
    535542        __(blelr cr2)
    536543        __(add imm0,imm0,arg_x)
     
    560567/* the store, record the address of the hash-table vector in the refmap,  */
    561568/* as well. */
    562         .globl C(egc_set_hash_key)       
     569        .globl C(egc_set_hash_key)     
     570        .globl C(egc_set_hash_key_did_store) 
    563571_spentry(set_hash_key)
    564572C(egc_set_hash_key):
     
    566574        __(la imm0,misc_data_offset(arg_y))
    567575        __(strx(arg_z,arg_x,imm0))
     576C(egc_set_hash_key_did_store):         
    568577        __(blelr cr2)
    569578        __(add imm0,imm0,arg_x)
  • release/1.9/source/lisp-kernel/x86-exceptions.c

    r15706 r15755  
    24022402  egc_store_node_conditional_success_end, egc_store_node_conditional_retry,
    24032403  egc_store_node_conditional_success_test,egc_store_node_conditional,
    2404   egc_set_hash_key, egc_gvset, egc_rplacd;
     2404  egc_set_hash_key, egc_gvset, egc_rplacd, egc_rplaca;
    24052405
    24062406/* We use (extremely) rigidly defined instruction sequences for consing,
     
    26442644    LispObj *ea = 0, val, root = 0;
    26452645    bitvector refbits = (bitvector)(lisp_global(REFBITS));
    2646     Boolean need_store = true, need_check_memo = true, need_memoize_root = false;
     2646    Boolean need_check_memo = true, need_memoize_root = false;
    26472647
    26482648    if (program_counter >= &egc_set_hash_key_conditional) {
     
    26782678#endif
    26792679      need_memoize_root = true;
    2680       need_store = false;
    26812680      xpGPR(xp,Iarg_z) = t_value;
    26822681    } else if (program_counter >= &egc_store_node_conditional) {
     
    27142713#endif
    27152714      xpGPR(xp,Iarg_z) = t_value;
    2716       need_store = false;
    27172715    } else if (program_counter >= &egc_set_hash_key) {
     2716      if (program_counter == &egc_set_hash_key) {
     2717        return;
     2718      }
    27182719#ifdef X8664
    27192720      root = xpGPR(xp,Iarg_x);
     
    27252726      need_memoize_root = true;
    27262727    } else if (program_counter >= &egc_gvset) {
     2728      /* This assumes that the store is the first instruction at _SPgvset.
     2729         As of late February 2013 - just before the 1.9 release, that's
     2730         a relatively recent change.
     2731         If the store has already completed, don't do it again.
     2732         See ticket:1058 for an example showing why this matters.
     2733      */
     2734      if (program_counter == &egc_gvset) {
     2735        return;
     2736      }
    27272737#ifdef X8664
    27282738      ea = (LispObj *) (xpGPR(xp,Iarg_x)+xpGPR(xp,Iarg_y)+misc_data_offset);
     
    27322742      val = xpGPR(xp,Iarg_z);
    27332743    } else if (program_counter >= &egc_rplacd) {
     2744      if (program_counter == &egc_rplacd) {
     2745        return;
     2746      }
    27342747      ea = (LispObj *) untag(xpGPR(xp,Iarg_y));
    27352748      val = xpGPR(xp,Iarg_z);
    27362749    } else {                      /* egc_rplaca */
     2750      if (program_counter == &egc_rplaca) {
     2751        return;
     2752      }
    27372753      ea =  ((LispObj *) untag(xpGPR(xp,Iarg_y)))+1;
    27382754      val = xpGPR(xp,Iarg_z);
    2739     }
    2740     if (need_store) {
    2741       *ea = val;
    27422755    }
    27432756    if (need_check_memo) {
  • release/1.9/source/lisp-kernel/x86-spentry32.s

    r15706 r15755  
    17221722        .globl C(egc_rplaca)
    17231723C(egc_rplaca):
     1724        /* pc_luser_xp() expects the store to be the first instruction here */
     1725        __(_rplaca(%arg_y,%arg_z))
    17241726        __(rcmpl(%arg_z,%arg_y))
    1725         __(_rplaca(%arg_y,%arg_z))
    17261727        __(ja 1f)
    172717280:      __(repret)
     
    17481749        .globl C(egc_rplacd)
    17491750C(egc_rplacd):
     1751        /* pc_luser_xp() expects the store to be the first instruction here */
     1752        __(_rplacd(%arg_y,%arg_z))
    17501753        __(rcmpl(%arg_z,%arg_y))
    1751         __(_rplacd(%arg_y,%arg_z))
    17521754        __(ja 1f)
    175317550:      __(repret)
     
    17761778        .globl C(egc_gvset)
    17771779C(egc_gvset):
     1780        /* pc_luser_xp() expects the store to be the first instruction here */
    17781781        __(movl %arg_z,misc_data_offset(%temp0,%arg_y))
    17791782        __(rcmpl(%arg_z,%temp0))
     
    18061809        .globl C(egc_set_hash_key)
    18071810C(egc_set_hash_key):
     1811        /* pc_luser_xp() expects the store to be the first instruction here */
    18081812        __(movl %arg_z,misc_data_offset(%temp0,%arg_y))
    18091813        __(rcmpl(%arg_z,%temp0))
  • release/1.9/source/lisp-kernel/x86-spentry64.s

    r15706 r15755  
    17631763        .globl C(egc_rplaca)
    17641764C(egc_rplaca):
     1765        /* pc_luser_xp() expects the store to be the first instruction here */
     1766        __(_rplaca(%arg_y,%arg_z))
    17651767        __(rcmpq(%arg_z,%arg_y))
    1766         __(_rplaca(%arg_y,%arg_z))
    17671768        __(ja 1f)
    176817690:      __(repret)
     
    17891790        .globl C(egc_rplacd)
    17901791C(egc_rplacd):         
     1792        /* pc_luser_xp() expects the store to be the first instruction here */
     1793        __(_rplacd(%arg_y,%arg_z))
    17911794        __(rcmpq(%arg_z,%arg_y))
    1792         __(_rplacd(%arg_y,%arg_z))
    17931795        __(ja 1f)
    179417960:      __(repret)
     
    18191821        .globl C(egc_gvset)
    18201822C(egc_gvset):
     1823        /* pc_luser_xp() expects the store to be the first instruction here */
     1824        __(movq %arg_z,misc_data_offset(%arg_x,%arg_y))
    18211825        __(rcmpq(%arg_z,%arg_x))
    1822         __(movq %arg_z,misc_data_offset(%arg_x,%arg_y))
    18231826        __(ja 1f)
    182418270:      __(repret)
     
    18501853        .globl C(egc_set_hash_key)
    18511854C(egc_set_hash_key): 
     1855        /* pc_luser_xp() expects the store to be the first instruction here */
     1856        __(movq %arg_z,misc_data_offset(%arg_x,%arg_y))
    18521857        __(rcmpq(%arg_z,%arg_x))
    1853         __(movq %arg_z,misc_data_offset(%arg_x,%arg_y))
    18541858        __(ja 1f)
    185518590:      __(repret)
Note: See TracChangeset for help on using the changeset viewer.