Index: generic/tclAlloc.c
===================================================================
RCS file: /cvsroot/tcl/tcl/generic/tclAlloc.c,v
retrieving revision 1.26
diff -u -r1.26 tclAlloc.c
--- generic/tclAlloc.c	13 Dec 2007 15:23:14 -0000	1.26
+++ generic/tclAlloc.c	16 Dec 2007 21:25:33 -0000
@@ -44,16 +44,6 @@
 #endif
 
 /*
- * Alignment for allocated memory.
- */
-
-#if defined(__APPLE__)
-#define ALLOCALIGN	16
-#else
-#define ALLOCALIGN	8
-#endif
-
-/*
  * The overhead on a block is at least 8 bytes. When free, this space contains
  * a pointer to the next free block, and the bottom two bits must be zero.
  * When in use, the first byte is set to MAGIC, and the second byte is the
@@ -66,7 +56,7 @@
 
 union overhead {
     union overhead *next;		/* when free */
-    unsigned char padding[ALLOCALIGN];	/* align struct to ALLOCALIGN bytes */
+    unsigned char padding[TCL_ALLOCALIGN];	/* align struct to TCL_ALLOCALIGN bytes */
     struct {
 	unsigned char magic0;		/* magic number */
 	unsigned char index;		/* bucket # */
@@ -110,7 +100,7 @@
  * precedes the data area returned to the user.
  */
 
-#define MINBLOCK	((sizeof(union overhead) + (ALLOCALIGN-1)) & ~(ALLOCALIGN-1))
+#define MINBLOCK	((sizeof(union overhead) + (TCL_ALLOCALIGN-1)) & ~(TCL_ALLOCALIGN-1))
 #define NBUCKETS	(13 - (MINBLOCK >> 4))
 #define MAXMALLOC	(1<<(NBUCKETS+2))
 static union overhead *nextf[NBUCKETS];
Index: generic/tclExecute.c
===================================================================
RCS file: /cvsroot/tcl/tcl/generic/tclExecute.c,v
retrieving revision 1.357
diff -u -r1.357 tclExecute.c
--- generic/tclExecute.c	13 Dec 2007 15:23:16 -0000	1.357
+++ generic/tclExecute.c	16 Dec 2007 21:25:34 -0000
@@ -603,7 +603,7 @@
 static const char *	GetSrcInfoForPc(unsigned char *pc, ByteCode *codePtr,
 			    int *lengthPtr);
 static Tcl_Obj **	GrowEvaluationStack(ExecEnv *eePtr, int growth,
-			    int move);
+	                    int move, int align);
 static void		IllegalExprOperandType(Tcl_Interp *interp,
 			    unsigned char *pc, Tcl_Obj *opndPtr);
 static void		InitByteCodeExecution(Tcl_Interp *interp);
@@ -616,8 +616,8 @@
 #endif /* TCL_COMPILE_DEBUG */
 static void		DeleteExecStack(ExecStack *esPtr);
 /* Useful elsewhere, make available in tclInt.h or stubs? */
-static Tcl_Obj **	StackAllocWords(Tcl_Interp *interp, int numWords);
-static Tcl_Obj **	StackReallocWords(Tcl_Interp *interp, int numWords);
+static Tcl_Obj **	StackAllocWords(Tcl_Interp *interp, int numWords, int align);
+static Tcl_Obj **	StackReallocWords(Tcl_Interp *interp, int numWords, int align);
 
 /*
  *----------------------------------------------------------------------
@@ -854,37 +854,69 @@
  *----------------------------------------------------------------------
  */
 
+#define WALLOCALIGN (TCL_ALLOCALIGN/sizeof(void *))
+
+
+/*
+ * This macro computes the correct offset to insure that the pointer returned
+ * is properly aligned.
+ * Note that we are only interested in the low bits of the address, so that
+ * the fact that PTR2INT may lose the high bits is irrelevant.
+ */
+
+#define COMPUTE_OFFSET(markerPtr, offset)	\
+    {\
+	int base = (PTR2UINT(markerPtr) & (WALLOCALIGN-1));\
+	int new  = (base + 2 + (WALLOCALIGN-1)) & ~(WALLOCALIGN-1);\
+	(offset) = (new - base);				   \
+    }
+
+
 static Tcl_Obj **
 GrowEvaluationStack(
     ExecEnv *eePtr,		/* Points to the ExecEnv with an evaluation
 				 * stack to enlarge. */
     int growth,			/* How much larger than the current used
 				 * size. */
-    int move)			/* 1 if move words since last marker. */
+    int move,			/* 1 if move words since last marker. */
+    int align)                  /* 1 if word alignment is not enough, align
+				 * according to TCL_ALLOCALIGN */
 {
     ExecStack *esPtr = eePtr->execStackPtr, *oldPtr = NULL;
     int newBytes, newElems, currElems;
     int needed = growth - (esPtr->endPtr - esPtr->tosPtr);
-    Tcl_Obj **markerPtr = esPtr->markerPtr;
+    Tcl_Obj **markerPtr = esPtr->markerPtr, **newMarkerPtr;
+    int offset = 2; /* default value */
 
     if (move) {
 	if (!markerPtr) {
 	    Tcl_Panic("STACK: Reallocating with no previous alloc");
 	}
+	offset = PTR2INT(*(markerPtr+1));	
 	if (needed <= 0) {
-	    return markerPtr + 1;
+	    return markerPtr + offset;
+	}
+    } else if (needed < -1) {
+	newMarkerPtr = (esPtr->tosPtr + 1);
+	if (align) {
+	    COMPUTE_OFFSET(newMarkerPtr, offset);
 	}
-    } else if (needed < 0) {
-	/*
-	 * Put a marker pointing to the previous marker in this stack, and
-	 * store it in esPtr as the current marker. Return a pointer to one
-	 * word past the marker.
-	 */
 
-	esPtr->markerPtr = ++esPtr->tosPtr;
-	*esPtr->markerPtr = (Tcl_Obj *) markerPtr;
-	return esPtr->markerPtr + 1;
+	if (needed + offset <= 0) {
+	    /*
+	     * Put a marker pointing to the previous marker in this stack, and 
+	     * store it in esPtr as the current marker. Return a pointer to
+	     * the word at (marker+offset).
+	     */
+
+	    esPtr->markerPtr = newMarkerPtr;
+	    *newMarkerPtr = (Tcl_Obj *) markerPtr;
+	    *(newMarkerPtr+1) = INT2PTR(offset);
+	    esPtr->tosPtr += offset;
+	    return newMarkerPtr + offset;
+	}
     }
+    offset = 2; /* reset to default */
 
     /*
      * Reset move to hold the number of words to be moved to new stack (if
@@ -894,7 +926,14 @@
     if (move) {
 	move = esPtr->tosPtr - markerPtr;
     }
-    needed = growth + move + 1; /* Add the marker. */
+
+    /*
+     * Add requirements for the marker and the offset; note that this is at
+     * most (WALLOCALIGN+1) words: one for the marker, one to store the
+     * offset, and at most an offset of (WALLOCALIGN-1)
+     */
+    
+    needed = growth + move + (align? (WALLOCALIGN+1) : 2);
 
     /*
      * Check if there is enough room in the next stack (if there is one, it
@@ -942,6 +981,10 @@
   newStackReady:
     eePtr->execStackPtr = esPtr;
 
+    if (align) {
+	COMPUTE_OFFSET(&esPtr->stackWords[0], offset);
+    }
+
     /*
      * Store a NULL marker at the beginning of the stack, to indicate that
      * this is the first marker in this stack and that rewinding to here
@@ -949,10 +992,12 @@
      */
 
     esPtr->stackWords[0] = NULL;
-    esPtr->markerPtr = esPtr->tosPtr = &esPtr->stackWords[0];
+    esPtr->stackWords[1] = INT2PTR(offset);
+    esPtr->markerPtr = &esPtr->stackWords[0];
+    esPtr->tosPtr = &esPtr->stackWords[offset-1];
 
     if (move) {
-	memcpy(&esPtr->stackWords[1], (markerPtr+1), move*sizeof(Tcl_Obj *));
+	memcpy(&esPtr->stackWords[offset], (markerPtr+PTR2INT(*(markerPtr+1))), move*sizeof(Tcl_Obj *));
 	esPtr->tosPtr += move;
 	oldPtr->markerPtr = (Tcl_Obj **) *markerPtr;
 	oldPtr->tosPtr = markerPtr-1;
@@ -966,7 +1011,7 @@
 	DeleteExecStack(oldPtr);
     }
 
-    return &esPtr->stackWords[1];
+    return &esPtr->stackWords[offset];
 }
 
 /*
@@ -990,7 +1035,8 @@
 static Tcl_Obj **
 StackAllocWords(
     Tcl_Interp *interp,
-    int numWords)
+    int numWords,
+    int align)
 {
     /*
      * Note that GrowEvaluationStack sets a marker in the stack. This marker
@@ -999,7 +1045,7 @@
 
     Interp *iPtr = (Interp *) interp;
     ExecEnv *eePtr = iPtr->execEnvPtr;
-    Tcl_Obj **resPtr = GrowEvaluationStack(eePtr, numWords, 0);
+    Tcl_Obj **resPtr = GrowEvaluationStack(eePtr, numWords, 0, align);
 
     eePtr->execStackPtr->tosPtr += numWords;
     return resPtr;
@@ -1008,11 +1054,12 @@
 static Tcl_Obj **
 StackReallocWords(
     Tcl_Interp *interp,
-    int numWords)
+    int numWords,
+    int align)
 {
     Interp *iPtr = (Interp *) interp;
     ExecEnv *eePtr = iPtr->execEnvPtr;
-    Tcl_Obj **resPtr = GrowEvaluationStack(eePtr, numWords, 1);
+    Tcl_Obj **resPtr = GrowEvaluationStack(eePtr, numWords, 1, align);
 
     eePtr->execStackPtr->tosPtr += numWords;
     return resPtr;
@@ -1043,7 +1090,7 @@
     esPtr = eePtr->execStackPtr;
     markerPtr = esPtr->markerPtr;
 
-    if ((markerPtr+1) != (Tcl_Obj **)freePtr) {
+    if (markerPtr + PTR2INT(*(markerPtr+1)) != (Tcl_Obj **)freePtr) {
 	Tcl_Panic("TclStackFree: incorrect freePtr. Call out of sequence?");
     }
 
@@ -1081,7 +1128,7 @@
 	return (void *) Tcl_Alloc(numBytes);
     }
 
-    return (void *) StackAllocWords(interp, numWords);
+    return (void *) StackAllocWords(interp, numWords, 1);
 }
 
 void *
@@ -1104,12 +1151,12 @@
     esPtr = eePtr->execStackPtr;
     markerPtr = esPtr->markerPtr;
 
-    if ((markerPtr+1) != (Tcl_Obj **)ptr) {
+    if ((markerPtr+PTR2INT(*(markerPtr+1))) != (Tcl_Obj **)ptr) {
 	Tcl_Panic("TclStackRealloc: incorrect ptr. Call out of sequence?");
     }
 
     numWords = (numBytes + (sizeof(Tcl_Obj *) - 1))/sizeof(Tcl_Obj *);
-    return (void *) StackReallocWords(interp, numWords);
+    return (void *) StackReallocWords(interp, numWords, 1);
 }
 
 /*
@@ -1617,7 +1664,7 @@
     catchTop = initCatchTop = (ptrdiff_t *) (
 	GrowEvaluationStack(iPtr->execEnvPtr,
 		codePtr->maxExceptDepth + sizeof(CmdFrame) +
-		    codePtr->maxStackDepth, 0) - 1);
+		codePtr->maxStackDepth, 0, 0) - 1);
     bcFramePtr = (CmdFrame *) (initCatchTop + codePtr->maxExceptDepth + 1);
     tosPtr = initTosPtr = ((Tcl_Obj **) (bcFramePtr + 1)) - 1;
     esPtr = iPtr->execEnvPtr->execStackPtr;
@@ -2100,7 +2147,7 @@
 
 	length = objc + (codePtr->maxStackDepth - TclGetInt4AtPtr(pc+1));
 	DECACHE_STACK_INFO();
-	moved = (GrowEvaluationStack(iPtr->execEnvPtr, length, 1) - 1)
+	moved = (GrowEvaluationStack(iPtr->execEnvPtr, length, 1, 0) - 1)
 		- (Tcl_Obj **) initCatchTop;
 
 	if (moved) {
Index: generic/tclInt.h
===================================================================
RCS file: /cvsroot/tcl/tcl/generic/tclInt.h,v
retrieving revision 1.358
diff -u -r1.358 tclInt.h
--- generic/tclInt.h	13 Dec 2007 15:23:18 -0000	1.358
+++ generic/tclInt.h	16 Dec 2007 21:25:36 -0000
@@ -2034,6 +2034,17 @@
 #define UCHAR(c) ((unsigned char) (c))
 
 /*
+ * This macro is used to properly align the memory allocated by Tcl, giving
+ * the same alignment as the native malloc
+ */
+
+#if defined(__APPLE__)
+#define TCL_ALLOCALIGN	16
+#else
+#define TCL_ALLOCALIGN	8
+#endif
+
+/*
  * This macro is used to determine the offset needed to safely allocate any
  * data structure in memory. Given a starting offset or size, it "rounds up"
  * or "aligns" the offset to the next 8-byte boundary so that any data
Index: generic/tclThreadAlloc.c
===================================================================
RCS file: /cvsroot/tcl/tcl/generic/tclThreadAlloc.c,v
retrieving revision 1.24
diff -u -r1.24 tclThreadAlloc.c
--- generic/tclThreadAlloc.c	13 Dec 2007 15:23:20 -0000	1.24
+++ generic/tclThreadAlloc.c	16 Dec 2007 21:25:36 -0000
@@ -40,16 +40,6 @@
 #define NOBJHIGH	1200
 
 /*
- * Alignment for allocated memory.
- */
-
-#if defined(__APPLE__)
-#define ALLOCALIGN	16
-#else
-#define ALLOCALIGN	8
-#endif
-
-/*
  * The following union stores accounting information for each block including
  * two small magic numbers and a bucket number when in use or a next pointer
  * when free. The original requested size (not including the Block overhead)
@@ -69,7 +59,7 @@
 	} u;
 	size_t reqSize;			/* Requested allocation size. */
     } b;
-    unsigned char padding[ALLOCALIGN];
+    unsigned char padding[TCL_ALLOCALIGN];
 } Block;
 #define nextBlock	b.u.next
 #define sourceBucket	b.u.s.bucket
@@ -83,7 +73,7 @@
  * of buckets in the bucket cache.
  */
 
-#define MINALLOC	((sizeof(Block) + 8 + (ALLOCALIGN-1)) & ~(ALLOCALIGN-1))
+#define MINALLOC	((sizeof(Block) + 8 + (TCL_ALLOCALIGN-1)) & ~(TCL_ALLOCALIGN-1))
 #define NBUCKETS	(11 - (MINALLOC >> 5))
 #define MAXALLOC	(MINALLOC << (NBUCKETS - 1))
 
