Merge updates from trunk.

FossilOrigin-Name: a447cf90ddfd2930274f58de4bae3b07f2886632

manifest

@@ -1,5 +1,5 @@
-C Experiments\swith\san\sOP_Unpack\sopcode\sthat\sextracts\smultiple\scolumns\sfrom\na\srecord\swithout\scaching.
-D 2015-10-15T20:17:15.103
+C Merge\supdates\sfrom\strunk.
+D 2015-10-15T21:12:27.435
 F Makefile.in 2ea961bc09e441874eb3d1bf7398e04feb24f3ee
 F Makefile.linux-gcc 7bc79876b875010e8c8f9502eb935ca92aa3c434
 F Makefile.msc 8e42cb55739cd8c12e1fd25401956e2019448f6a
@@ -303,7 +303,7 @@ F src/journal.c b4124532212b6952f42eb2c12fa3c25701d8ba8d
 F src/legacy.c ba1863ea58c4c840335a84ec276fc2b25e22bc4e
 F src/lempar.c d344a95d60c24e2f490ee59db9784b1b17439012
 F src/loadext.c 18586e45a215325f15096821e9c082035d4fb810
-F src/main.c fec97668771438033a7559883401067b139729e1
+F src/main.c 2082c1c7aa1687849848581e084f6046c503841d
 F src/malloc.c 0a2e42b835c980ba91c17866e9b6a9810ff54d75
 F src/mem0.c 6a55ebe57c46ca1a7d98da93aaa07f99f1059645
 F src/mem1.c 52485a88f22649c3b3b4f3eb15760505d49ccf71
@@ -312,11 +312,11 @@ F src/mem3.c 8768ac94694f31ffaf8b4d0ea5dc08af7010a35a
 F src/mem5.c c1ab1153bd6443bdf6f71e4213c6fb31221b9eb7
 F src/memjournal.c 3eb2c0b51adbd869cb6a44780323f05fa904dc85
 F src/msvc.h d9ba56c6851227ab44b3f228a35f3f5772296495
-F src/mutex.c 8e45800ee78e0cd1f1f3fe8e398853307f4a085c
+F src/mutex.c 40dc52f7525fa86f35dff2a7c9b6e6870240952a
 F src/mutex.h 779d588e3b7756ec3ecf7d78cde1d84aba414f85
-F src/mutex_noop.c 9d4309c075ba9cc7249e19412d3d62f7f94839c4
-F src/mutex_unix.c a94b46f3f7beba307dde1b298b0f99f9c3677a93
-F src/mutex_w32.c 5e6fe1c298fb5a8a15aaed4161d5759311431c17
+F src/mutex_noop.c f03e26ba8258399da23b51234f6b6a97197c1900
+F src/mutex_unix.c 77d84839735aec71f9fe731bfd845d81cec2bb65
+F src/mutex_w32.c c3a5049bc413dd8321480b28f275fbf2b99c846e
 F src/notify.c 9711a7575036f0d3040ba61bc6e217f13a9888e7
 F src/os.c 8fd25588eeba74068d41102d26810e216999b6c8
 F src/os.h 3e57a24e2794a94d3cf2342c6d9a884888cd96bf
@@ -338,12 +338,12 @@ F src/printf.c 0c4bcdd1c2e2521024f0a69cb5eb334f86b3652a
 F src/random.c ba2679f80ec82c4190062d756f22d0c358180696
 F src/resolve.c 1954a0f01bf65d78d7d559aea3d5c67f33376d91
 F src/rowset.c eccf6af6d620aaa4579bd3b72c1b6395d9e9fa1e
-F src/select.c a4478981ce53cb7e28d0252417deece6ad5fe693
+F src/select.c dbf1fb82317043304da334a33206add211487f96
 F src/shell.c d25df04168d6ba5a4fa05bdbf859df667f9eb621
 F src/sqlite.h.in 839c818e16ea68703d90d17bd2bb3607191debce
 F src/sqlite3.rc 992c9f5fb8285ae285d6be28240a7e8d3a7f2bad
 F src/sqlite3ext.h 4b66e3e3435da4b4c8c83696d0349f0c503b3924
-F src/sqliteInt.h 1ad779ee62efee60494af0a75d8d45592f9f53c3
+F src/sqliteInt.h 2d82464793c7d07b01dfcdc43942a27063ea398d
 F src/sqliteLimit.h 216557999cb45f2e3578ed53ebefe228d779cb46
 F src/status.c 286f6398a4d2cd1e8ff0771e3d30f8dddb4768ea
 F src/table.c 51b46b2a62d1b3a959633d593b89bab5e2c9155e
@@ -401,7 +401,7 @@ F src/update.c aa10336a2719bd1b9f89004f3d7ba6d566623a49
 F src/utf.c fc6b889ba0779b7722634cdeaa25f1930d93820c
 F src/util.c fc612367108b74573c5fd13a85d0a23027f438bd
 F src/vacuum.c 2ddd5cad2a7b9cef7f9e431b8c7771634c6b1701
-F src/vdbe.c a0a2aea6a146e2479bdb7dba584f3e625ceccc30
+F src/vdbe.c 61bd96c72f103d2e96de6ab7852dc009dc9bb6b3
 F src/vdbe.h 4bc88bd0e06f8046ee6ab7487c0015e85ad949ad
 F src/vdbeInt.h 8b867eac234e28627ffcace3cd4b4b79bbec664b
 F src/vdbeapi.c 020681b943e77766b32ae1cddf86d7831b7374ca
@@ -1391,10 +1391,7 @@ F tool/vdbe_profile.tcl 67746953071a9f8f2f668b73fe899074e2c6d8c1
 F tool/warnings-clang.sh f6aa929dc20ef1f856af04a730772f59283631d4
 F tool/warnings.sh 48bd54594752d5be3337f12c72f28d2080cb630b
 F tool/win/sqlite.vsix deb315d026cc8400325c5863eef847784a219a2f
-P 871e091df651b2275a672c35ff938bd4b6db0d7f
-R 12f17dff849f2a06a10012eebf93b957
-T *branch * unpack-opcode
-T *sym-unpack-opcode *
-T -sym-trunk *
-U drh
-Z 51853eb094abb609c64d30de1af24213
+P 8d69983dc2b94ca752259dcec360c32d60a8e9dd 871e091df651b2275a672c35ff938bd4b6db0d7f
+R 2967669474e0bc8a932a9ea55508690e
+U mistachkin
+Z 30c10e55f7847c468e81b5b9567db928

manifest.uuid

@@ -1 +1 @@
-39ae92f5c63de4b95502f438dc7e9f2669efdf91
+a447cf90ddfd2930274f58de4bae3b07f2886632

src/main.c

@@ -391,14 +391,18 @@ int sqlite3_config(int op, ...){
 #if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-63666-48755 */
     case SQLITE_CONFIG_MUTEX: {
       /* Specify an alternative mutex implementation */
-      sqlite3GlobalConfig.mutex = *va_arg(ap, sqlite3_mutex_methods*);
+      sqlite3MutexCopy(&sqlite3GlobalConfig.mutex,
+                       va_arg(ap, sqlite3_mutex_methods*));
+      sqlite3MemoryBarrier();
       break;
     }
 #endif
 #if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-14450-37597 */
     case SQLITE_CONFIG_GETMUTEX: {
       /* Retrieve the current mutex implementation */
-      *va_arg(ap, sqlite3_mutex_methods*) = sqlite3GlobalConfig.mutex;
+      sqlite3MemoryBarrier();
+      sqlite3MutexCopy(va_arg(ap, sqlite3_mutex_methods*),
+                       &sqlite3GlobalConfig.mutex);
       break;
     }
 #endif

src/mutex.c

@@ -26,35 +26,49 @@ static SQLITE_WSD int mutexIsInit = 0;
 
 
 #ifndef SQLITE_MUTEX_OMIT
+/*
+** Copies a mutex implementation.  Both arguments must point to valid
+** memory.
+*/
+void sqlite3MutexCopy(
+  sqlite3_mutex_methods *pTo,
+  sqlite3_mutex_methods const *pFrom
+){
+  pTo->xMutexInit = pFrom->xMutexInit;
+  pTo->xMutexEnd = pFrom->xMutexEnd;
+  pTo->xMutexFree = pFrom->xMutexFree;
+  pTo->xMutexEnter = pFrom->xMutexEnter;
+  pTo->xMutexTry = pFrom->xMutexTry;
+  pTo->xMutexLeave = pFrom->xMutexLeave;
+  pTo->xMutexHeld = pFrom->xMutexHeld;
+  pTo->xMutexNotheld = pFrom->xMutexNotheld;
+  pTo->xMutexAlloc = pFrom->xMutexAlloc;
+}
+
 /*
 ** Initialize the mutex system.
 */
 int sqlite3MutexInit(void){ 
-  int rc = SQLITE_OK;
-  if( !sqlite3GlobalConfig.mutex.xMutexAlloc ){
+  int rc;
+
+  sqlite3MemoryBarrier();
+  if( sqlite3CompareAndSwap(
+                   (void * volatile *)&sqlite3GlobalConfig.mutex.xMutexAlloc,
+                   0, sqlite3GlobalConfig.mutex.xMutexAlloc)==0 ){
     /* If the xMutexAlloc method has not been set, then the user did not
     ** install a mutex implementation via sqlite3_config() prior to 
     ** sqlite3_initialize() being called. This block copies pointers to
     ** the default implementation into the sqlite3GlobalConfig structure.
     */
     sqlite3_mutex_methods const *pFrom;
-    sqlite3_mutex_methods *pTo = &sqlite3GlobalConfig.mutex;
 
     if( sqlite3GlobalConfig.bCoreMutex ){
       pFrom = sqlite3DefaultMutex();
     }else{
       pFrom = sqlite3NoopMutex();
     }
-    pTo->xMutexInit = pFrom->xMutexInit;
-    pTo->xMutexEnd = pFrom->xMutexEnd;
-    pTo->xMutexFree = pFrom->xMutexFree;
-    pTo->xMutexEnter = pFrom->xMutexEnter;
-    pTo->xMutexTry = pFrom->xMutexTry;
-    pTo->xMutexLeave = pFrom->xMutexLeave;
-    pTo->xMutexHeld = pFrom->xMutexHeld;
-    pTo->xMutexNotheld = pFrom->xMutexNotheld;
+    sqlite3MutexCopy(&sqlite3GlobalConfig.mutex, pFrom);
     sqlite3MemoryBarrier();
-    pTo->xMutexAlloc = pFrom->xMutexAlloc;
   }
   assert( sqlite3GlobalConfig.mutex.xMutexInit );
   rc = sqlite3GlobalConfig.mutex.xMutexInit();

src/mutex_noop.c

@@ -29,6 +29,28 @@
 
 #ifndef SQLITE_MUTEX_OMIT
 
+/*
+** Try to provide an atomic compare-and-swap operation on a void pointer,
+** needed for initialization only.
+*/
+void *sqlite3NoopCompareAndSwap(
+  void *volatile *pCurVal,
+  void *cmpVal,
+  void *swapVal
+){
+  /*
+  ** This platform may not have a way to perform an atomic compare-and-swap
+  ** operation; therefore, use the fallback algorithm.
+  **
+  ** WARNING: This code is almost certainly not thread-safe.
+  */
+  void *oldVal = *pCurVal;
+  if( oldVal==cmpVal ){
+    *pCurVal = swapVal;
+  }
+  return oldVal;
+}
+
 #ifndef SQLITE_DEBUG
 /*
 ** Stub routines for all mutex methods.

src/mutex_unix.c

@@ -93,6 +93,34 @@ void sqlite3MemoryBarrier(void){
 #endif
 }
 
+/*
+** Try to provide an atomic compare-and-swap operation on a void pointer,
+** needed for initialization only.
+*/
+void *sqlite3CompareAndSwap(
+  void *volatile *pCurVal,
+  void *cmpVal,
+  void *swapVal
+){
+#if defined(SQLITE_COMPARE_AND_SWAP)
+  return SQLITE_COMPARE_AND_SWAP(pCurVal, cmpVal, swapVal);
+#elif defined(__GNUC__) && GCC_VERSION>=4001000 && SQLITE_PTRSIZE>4
+  return (void *)__sync_val_compare_and_swap_8(
+      (u64 volatile *)pCurVal, (u64)cmpVal, (u64)swapVal);
+#elif defined(__GNUC__) && GCC_VERSION>=4001000
+  return (void *)__sync_val_compare_and_swap_4(
+      (u32 volatile *)pCurVal, (u32)cmpVal, (u32)swapVal);
+#else
+  /*
+  ** This platform may not have a way to perform an atomic compare-and-swap
+  ** operation; therefore, use the fallback algorithm.
+  **
+  ** WARNING: This code is almost certainly not thread-safe.
+  */
+  return sqlite3NoopCompareAndSwap(pCurVal, cmpVal, swapVal);
+#endif
+}
+
 /*
 ** Initialize and deinitialize the mutex subsystem.
 */

src/mutex_w32.c

@@ -95,6 +95,28 @@ void sqlite3MemoryBarrier(void){
 #endif
 }
 
+/*
+** Try to provide an atomic compare-and-swap operation on a void pointer,
+** needed for initialization only.
+*/
+void *sqlite3CompareAndSwap(
+  void * volatile *pCurVal,
+  void *cmpVal,
+  void *swapVal
+){
+#if defined(SQLITE_COMPARE_AND_SWAP)
+  return SQLITE_COMPARE_AND_SWAP(pCurVal, cmpVal, swapVal);
+#elif SQLITE_PTRSIZE>4
+  return (void *)InterlockedCompareExchange64(
+      (LONGLONG SQLITE_WIN32_VOLATILE *)pCurVal, (LONGLONG)swapVal,
+      (LONGLONG)cmpVal);
+#else
+  return (void *)InterlockedCompareExchange(
+      (LONG SQLITE_WIN32_VOLATILE *)pCurVal, (LONG)swapVal,
+      (LONG)cmpVal);
+#endif
+}
+
 /*
 ** Initialize and deinitialize the mutex subsystem.
 */

src/select.c

@@ -1230,16 +1230,15 @@ static void generateSortTail(
     codeOffset(v, p->iOffset, addrContinue);
     sqlite3VdbeAddOp3(v, OP_SorterData, iTab, regSortOut, iSortTab);
     bSeq = 0;
-    sqlite3VdbeAddOp4Int(v, OP_Unpack, regSortOut, regRow, nSortData, nKey);
   }else{
     addr = 1 + sqlite3VdbeAddOp2(v, OP_Sort, iTab, addrBreak); VdbeCoverage(v);
     codeOffset(v, p->iOffset, addrContinue);
     iSortTab = iTab;
     bSeq = 1;
-    for(i=0; i<nSortData; i++){
-      sqlite3VdbeAddOp3(v, OP_Column, iSortTab, nKey+bSeq+i, regRow+i);
-      VdbeComment((v, "%s", aOutEx[i].zName ? aOutEx[i].zName : aOutEx[i].zSpan));
-    }
+  }
+  for(i=0; i<nSortData; i++){
+    sqlite3VdbeAddOp3(v, OP_Column, iSortTab, nKey+bSeq+i, regRow+i);
+    VdbeComment((v, "%s", aOutEx[i].zName ? aOutEx[i].zName : aOutEx[i].zSpan));
   }
   switch( eDest ){
     case SRT_EphemTab: {
@@ -5341,9 +5340,11 @@ int sqlite3Select(
       if( groupBySort ){
         sqlite3VdbeAddOp3(v, OP_SorterData, sAggInfo.sortingIdx,
                           sortOut, sortPTab);
-        sqlite3VdbeAddOp4Int(v, OP_Unpack, sortOut, iBMem, pGroupBy->nExpr, 0);
-      }else{
-        for(j=0; j<pGroupBy->nExpr; j++){
+      }
+      for(j=0; j<pGroupBy->nExpr; j++){
+        if( groupBySort ){
+          sqlite3VdbeAddOp3(v, OP_Column, sortPTab, j, iBMem+j);
+        }else{
           sAggInfo.directMode = 1;
           sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr, iBMem+j);
         }

src/sqliteInt.h

@@ -3196,15 +3196,27 @@ const sqlite3_mem_methods *sqlite3MemGetMemsys5(void);
 #ifndef SQLITE_MUTEX_OMIT
   sqlite3_mutex_methods const *sqlite3DefaultMutex(void);
   sqlite3_mutex_methods const *sqlite3NoopMutex(void);
+  void *sqlite3NoopCompareAndSwap(void * volatile *, void *, void *);
   sqlite3_mutex *sqlite3MutexAlloc(int);
   int sqlite3MutexInit(void);
   int sqlite3MutexEnd(void);
 #endif
 #if !defined(SQLITE_MUTEX_OMIT) && !defined(SQLITE_MUTEX_NOOP)
+  void sqlite3MutexCopy(sqlite3_mutex_methods *, sqlite3_mutex_methods const *);
   void sqlite3MemoryBarrier(void);
 #else
+# define sqlite3MutexCopy(x,y)
 # define sqlite3MemoryBarrier()
 #endif
+#if !defined(SQLITE_MUTEX_OMIT)
+# if !defined(SQLITE_MUTEX_NOOP)
+   void *sqlite3CompareAndSwap(void * volatile *, void *, void *);
+# else
+#  define sqlite3CompareAndSwap sqlite3NoopCompareAndSwap
+# endif
+#else
+# define sqlite3CompareAndSwap(x,y,z)
+#endif
 
 sqlite3_int64 sqlite3StatusValue(int);
 void sqlite3StatusUp(int, int);

src/vdbe.c

@@ -2614,51 +2614,6 @@ op_column_error:
   break;
 }
 
-/* Opcode: Unpack P1 P2 P3 P4 *
-** Synopsis: r[P2@P3] = unpack(P1)
-**
-** Decode the P3 fields of the record object held in register P1
-** start with the P4-th field and store the values in registers P2
-** and following.
-*/
-case OP_Unpack: {
-  const unsigned char *aKey;
-  int d; 
-  u32 idx;                        /* Offset in aKey[] to read from */
-  u16 u;                          /* Unsigned loop counter */
-  u32 szHdr;
-  int nField;     
-  u32 serial_type;
-  int iOfst;                      /* Skip this many fields */
-
-  pIn1 = &aMem[pOp->p1];
-  assert( pIn1->flags & MEM_Blob );
-  aKey = (const unsigned char*)pIn1->z;
-  pOut = &aMem[pOp->p2];
-  nField = pOp->p3;
-  assert( pOp->p4type==P4_INT32 );
-  iOfst = pOp->p4.i;
-  idx = getVarint32(aKey, szHdr);
-  d = szHdr;
-  u = 0;
-  while( idx<szHdr && d<=pIn1->n ){
-    idx += getVarint32(&aKey[idx], serial_type);
-    if( iOfst ){
-      iOfst--;
-      d += sqlite3VdbeSerialTypeLen(serial_type);
-    }else{
-      memAboutToChange(p, pOut);
-      sqlite3VdbeMemSetNull(pOut);
-      pOut->enc = encoding;
-      d += sqlite3VdbeSerialGet(&aKey[d], serial_type, pOut);
-      REGISTER_TRACE((int)(pOut - aMem), pOut);
-      pOut++;
-      if( (++u)>=nField ) break;
-    }
-  }
-  break;
-}
-
 /* Opcode: Affinity P1 P2 * P4 *
 ** Synopsis: affinity(r[P1@P2])
 **