clones/php-src
1
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2024-09-21 09:57:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

reworked the patch, less new stuff but worky

Browse Source 
TLS is already used in TSRM, the way exporting the tsrm cache through
a thread local variable is not portable. Additionally, the current
patch suffers from bugs which are hard to find, but prevent it to
be worky with apache. What is done here is mainly uses the idea
from the RFC patch, but

- __thread variable is removed
- offset math and declarations are removed
- extra macros and definitions are removed

What is done merely is

- use an inline function to access the tsrm cache. The function uses
  the portable tsrm_tls_get macro which is cheap
- all the TSRM_* macros are set to placebo. Thus this opens the way
  remove them later

Except that, the logic is old. TSRMLS_FETCH will have to be done once
per thread, then tsrm_get_ls_cache() can be used. Things seeming to be
worky are cli, cli server and apache. I also tried to enable bz2
shared and it has worked out of the box. The change is yet minimal
diffing to the current master bus is a worky start, IMHO. Though will
have to recheck the other previously done SAPIs - embed and cgi.

The offsets can be added to the tsrm_resource_type struct, then
it'll not be needed to declare them in the userspace. Even the
"done" member type can be changed to int16 or smaller, then adding
the offset as int16 will not change the struct size. As well on the
todo might be removing the hashed storage, thread_id != thread_id and
linked list logic in favour of the explicit TLS operations.
This commit is contained in:
Anatol Belski 2014-09-25 18:48:27 +02:00
parent a2dd606942
commit d11734b4b0
64 changed files with 258 additions and 610 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

147
TSRM/TSRM.c
View File

@ -23,7 +23,7 @@
typedef struct _tsrm_tls_entry tsrm_tls_entry;
struct _tsrm_tls_entry {
void *storage;
void **storage;
int count;
THREAD_T thread_id;
tsrm_tls_entry *next;
@ -31,7 +31,6 @@ struct _tsrm_tls_entry {
typedef struct {
ts_rsrc_offset offset;
size_t size;
ts_allocate_ctor ctor;
ts_allocate_dtor dtor;
@ -43,7 +42,7 @@ typedef struct {
static tsrm_tls_entry **tsrm_tls_table=NULL;
static int tsrm_tls_table_size;
static ts_rsrc_id id_count;
static size_t rsrcs_size;
/* The resource sizes table */
static tsrm_resource_type *resource_types_table=NULL;
static int resource_types_table_size;
@ -62,62 +61,31 @@ int tsrm_error(int level, const char *format, ...);
static int tsrm_error_level;
static FILE *tsrm_error_file;
#ifdef USE___THREAD
TSRM_TLS void *tsrm_ls_cache = 0;
#endif
#ifdef PASS_TSRMLS
# define CALL_TSRMG_CTOR(ctor, globale, storage) (ctor)((globale), (storage))
# define CALL_TSRMG_DTOR(ctor, globale, storage) (ctor)((globale), (storage))
# define CALL_NEW_THREAD_BEGIN_HANDLER(thread_id, storage) tsrm_new_thread_begin_handler((thread_id), (storage))
# define CALL_NEW_THREAD_END_HANDLER(thread_id, storage) tsrm_new_thread_end_handler((thread_id), (storage))
#else
# define CALL_TSRMG_CTOR(ctor, globale, storage) (ctor)((globale))
# define CALL_TSRMG_DTOR(ctor, globale, storage) (ctor)((globale))
# define CALL_NEW_THREAD_BEGIN_HANDLER(thread_id, storage) tsrm_new_thread_begin_handler((thread_id))
# define CALL_NEW_THREAD_END_HANDLER(thread_id, storage) tsrm_new_thread_end_handler((thread_id))
#endif
#ifndef TSRM_MM_ALIGNMENT
# define TSRM_MM_ALIGNMENT 8
#elif TSRM_MM_ALIGNMENT < 4
# undef TSRM_MM_ALIGNMENT
# define TSRM_MM_ALIGNMENT 8
#endif
#define TSRMG_PTR(storage, offset) ((void *)((tsrm_uintptr_t)storage + offset))
#ifdef USE___THREAD
# define TSRM_RETURN_TSRM_LS(array) array
#else
# define TSRM_RETURN_TSRM_LS(array) &array
#endif
#if TSRM_DEBUG
#define TSRM_ERROR(args) tsrm_error args
#define TSRM_SAFE_RETURN_RSRC(array, id, range) \
#define TSRM_SAFE_RETURN_RSRC(array, offset, range) \
{ \
int unshuffled_id = TSRM_UNSHUFFLE_RSRC_ID(id); \
int unshuffled_offset = TSRM_UNSHUFFLE_RSRC_ID(offset); \
\
if (id==0) { \
return TSRM_RETURN_TSRM_LS(array); \
} else if ((unshuffled_id)>=0 && (unshuffled_id)<(range)) { \
if (offset==0) { \
return &array; \
} else if ((unshuffled_offset)>=0 && (unshuffled_offset)<(range)) { \
TSRM_ERROR((TSRM_ERROR_LEVEL_INFO, "Successfully fetched resource id %d for thread id %ld - 0x%0.8X", \
unshuffled_id, (long) thread_resources->thread_id, TSRMG_PTR(array, resource_types_table[unshuffled_id].offset))); \
return TSRMG_PTR(array, resource_types_table[unshuffled_id].offset); \
unshuffled_offset, (long) thread_resources->thread_id, array[unshuffled_offset])); \
return array[unshuffled_offset]; \
} else { \
TSRM_ERROR((TSRM_ERROR_LEVEL_ERROR, "Resource id %d is out of range (%d..%d)", \
unshuffled_id, TSRM_SHUFFLE_RSRC_ID(0), TSRM_SHUFFLE_RSRC_ID(thread_resources->count-1))); \
unshuffled_offset, TSRM_SHUFFLE_RSRC_ID(0), TSRM_SHUFFLE_RSRC_ID(thread_resources->count-1))); \
return NULL; \
} \
}
#else
#define TSRM_ERROR(args)
#define TSRM_SAFE_RETURN_RSRC(array, id, range) \
if (id==0) { \
return TSRM_RETURN_TSRM_LS(array); \
} else { \
return TSRMG_PTR(array, resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(id)].offset); \
#define TSRM_SAFE_RETURN_RSRC(array, offset, range) \
if (offset==0) { \
return &array; \
} else { \
return array[TSRM_UNSHUFFLE_RSRC_ID(offset)]; \
}
#endif
@ -207,8 +175,11 @@ TSRM_API void tsrm_shutdown(void)
next_p = p->next;
for (j=0; j<p->count; j++) {
if (resource_types_table && !resource_types_table[j].done && resource_types_table[j].dtor) {
CALL_TSRMG_CTOR(resource_types_table[j].dtor, TSRMG_PTR(p->storage, resource_types_table[j].offset), &p->storage);
if (p->storage[j]) {
if (resource_types_table && !resource_types_table[j].done && resource_types_table[j].dtor) {
resource_types_table[j].dtor(p->storage[j], &p->storage);
}
free(p->storage[j]);
}
}
free(p->storage);
@ -241,10 +212,9 @@ TSRM_API void tsrm_shutdown(void)
/* allocates a new thread-safe-resource id */
TSRM_API ts_rsrc_id ts_allocate_id(ts_rsrc_id *rsrc_id, ts_rsrc_offset *rsrc_offset, size_t size, ts_allocate_ctor ctor, ts_allocate_dtor dtor)
TSRM_API ts_rsrc_id ts_allocate_id(ts_rsrc_id *rsrc_id, size_t size, ts_allocate_ctor ctor, ts_allocate_dtor dtor)
{
int i;
ts_rsrc_offset offset = 0;
TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Obtaining a new resource id, %d bytes", size));
@ -265,17 +235,6 @@ TSRM_API ts_rsrc_id ts_allocate_id(ts_rsrc_id *rsrc_id, ts_rsrc_offset *rsrc_off
}
resource_types_table_size = id_count;
}
if (TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id) > 0) {
offset = resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id-1)].offset
+resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id-1)].size;
}
offset = ((TSRM_MM_ALIGNMENT + offset - 1) & ~(TSRM_MM_ALIGNMENT - 1));
if (rsrc_offset) {
*rsrc_offset = offset;
}
resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].offset = offset;
resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].size = size;
resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].ctor = ctor;
resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].dtor = dtor;
@ -289,13 +248,11 @@ TSRM_API ts_rsrc_id ts_allocate_id(ts_rsrc_id *rsrc_id, ts_rsrc_offset *rsrc_off
if (p->count < id_count) {
int j;
p->storage = realloc(p->storage, offset + size);
#ifdef USE___THREAD
tsrm_ls_cache = p->storage;
#endif
p->storage = (void *) realloc(p->storage, sizeof(void *)*id_count);
for (j=p->count; j<id_count; j++) {
p->storage[j] = (void *) malloc(resource_types_table[j].size);
if (resource_types_table[j].ctor) {
CALL_TSRMG_CTOR(resource_types_table[j].ctor, TSRMG_PTR(p->storage, resource_types_table[j].offset), &p->storage);
resource_types_table[j].ctor(p->storage[j], &p->storage);
}
}
p->count = id_count;
@ -303,10 +260,9 @@ TSRM_API ts_rsrc_id ts_allocate_id(ts_rsrc_id *rsrc_id, ts_rsrc_offset *rsrc_off
p = p->next;
}
}
rsrcs_size = offset + size;
tsrm_mutex_unlock(tsmm_mutex);
TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Successfully allocated new resource id %d, offset %u", *rsrc_id, *rsrc_offset));
TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Successfully allocated new resource id %d", *rsrc_id));
return *rsrc_id;
}
@ -317,7 +273,7 @@ static void allocate_new_resource(tsrm_tls_entry **thread_resources_ptr, THREAD_
TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Creating data structures for thread %x", thread_id));
(*thread_resources_ptr) = (tsrm_tls_entry *) malloc(sizeof(tsrm_tls_entry));
(*thread_resources_ptr)->storage = malloc(rsrcs_size);
(*thread_resources_ptr)->storage = (void **) malloc(sizeof(void *)*id_count);
(*thread_resources_ptr)->count = id_count;
(*thread_resources_ptr)->thread_id = thread_id;
(*thread_resources_ptr)->next = NULL;
@ -325,23 +281,23 @@ static void allocate_new_resource(tsrm_tls_entry **thread_resources_ptr, THREAD_
/* Set thread local storage to this new thread resources structure */
tsrm_tls_set(*thread_resources_ptr);
#ifdef USE___THREAD
tsrm_ls_cache = (*thread_resources_ptr)->storage;
#endif
if (tsrm_new_thread_begin_handler) {
CALL_NEW_THREAD_BEGIN_HANDLER(thread_id, &(*thread_resources_ptr)->storage);
tsrm_new_thread_begin_handler(thread_id, &((*thread_resources_ptr)->storage));
}
for (i=0; i<id_count; i++) {
if (!resource_types_table[i].done) {
if (resource_types_table[i].done) {
(*thread_resources_ptr)->storage[i] = NULL;
} else
{
(*thread_resources_ptr)->storage[i] = (void *) malloc(resource_types_table[i].size);
if (resource_types_table[i].ctor) {
CALL_TSRMG_CTOR(resource_types_table[i].ctor, TSRMG_PTR((*thread_resources_ptr)->storage, resource_types_table[i].offset), &(*thread_resources_ptr)->storage);
resource_types_table[i].ctor((*thread_resources_ptr)->storage[i], &(*thread_resources_ptr)->storage);
}
}
}
if (tsrm_new_thread_end_handler) {
CALL_NEW_THREAD_END_HANDLER(thread_id, &(*thread_resources_ptr)->storage);
tsrm_new_thread_end_handler(thread_id, &((*thread_resources_ptr)->storage));
}
tsrm_mutex_unlock(tsmm_mutex);
@ -434,10 +390,12 @@ void tsrm_free_interpreter_context(void *context)
for (i=0; i<thread_resources->count; i++) {
if (resource_types_table[i].dtor) {
CALL_TSRMG_DTOR(resource_types_table[i].dtor, TSRMG_PTR(thread_resources->storage, resource_types_table[i].offset), &thread_resources->storage);
resource_types_table[i].dtor(thread_resources->storage[i], &thread_resources->storage);
}
}
for (i=0; i<thread_resources->count; i++) {
free(thread_resources->storage[i]);
}
free(thread_resources->storage);
free(thread_resources);
thread_resources = next;
@ -455,10 +413,6 @@ void *tsrm_set_interpreter_context(void *new_ctx)
/* Set thread local storage to this new thread resources structure */
tsrm_tls_set(new_ctx);
#ifdef USE___THREAD
tsrm_ls_cache = ((tsrm_tls_entry*)new_ctx)->storage;
#endif
/* return old context, so caller can restore it when they're done */
return current;
@ -501,9 +455,12 @@ void ts_free_thread(void)
if (thread_resources->thread_id == thread_id) {
for (i=0; i<thread_resources->count; i++) {
if (resource_types_table[i].dtor) {
CALL_TSRMG_DTOR(resource_types_table[i].dtor, TSRMG_PTR(thread_resources->storage, resource_types_table[i].offset), &thread_resources->storage);
resource_types_table[i].dtor(thread_resources->storage[i], &thread_resources->storage);
}
}
for (i=0; i<thread_resources->count; i++) {
free(thread_resources->storage[i]);
}
free(thread_resources->storage);
if (last) {
last->next = thread_resources->next;
@ -540,9 +497,12 @@ void ts_free_worker_threads(void)
if (thread_resources->thread_id != thread_id) {
for (i=0; i<thread_resources->count; i++) {
if (resource_types_table[i].dtor) {
CALL_TSRMG_DTOR(resource_types_table[i].dtor, TSRMG_PTR(thread_resources->storage, resource_types_table[i].offset), &thread_resources->storage);
resource_types_table[i].dtor(thread_resources->storage[i], &thread_resources->storage);
}
}
for (i=0; i<thread_resources->count; i++) {
free(thread_resources->storage[i]);
}
free(thread_resources->storage);
if (last) {
last->next = thread_resources->next;
@ -581,10 +541,12 @@ void ts_free_id(ts_rsrc_id id)
tsrm_tls_entry *p = tsrm_tls_table[i];
while (p) {
if (p->count > j) {
if (p->count > j && p->storage[j]) {
if (resource_types_table && resource_types_table[j].dtor) {
CALL_TSRMG_DTOR(resource_types_table[j].dtor, TSRMG_PTR(p->storage, resource_types_table[j].offset), &p->storage);
resource_types_table[j].dtor(p->storage[j], &p->storage);
}
free(p->storage[j]);
p->storage[j] = NULL;
}
p = p->next;
}
@ -829,14 +791,9 @@ void tsrm_error_set(int level, char *debug_filename)
#endif
}
TSRM_API void *get_tsrm_ls_cache(void)
TSRM_API inline void *tsrm_get_ls_cache(void)
{
return tsrm_ls_cache;
}
TSRM_API void set_tsrm_ls_cache(void **cache)
{
tsrm_ls_cache = *cache;
return tsrm_tls_get();
}
#endif /* ZTS */

103
TSRM/TSRM.h
View File

@ -21,8 +21,6 @@
#endif
#ifdef TSRM_WIN32
# define TSRM_EXP_API __declspec(dllexport)
# define TSRM_IMP_API __declspec(dllimport)
# ifdef TSRM_EXPORTS
# define TSRM_API __declspec(dllexport)
# else
@ -30,12 +28,8 @@
# endif
#elif defined(__GNUC__) && __GNUC__ >= 4
# define TSRM_API __attribute__ ((visibility("default")))
# define TSRM_EXP_API TSRM_API
# define TSRM_IMP_API TSRM_API
#else
# define TSRM_API
# define TSRM_EXP_API
# define TSRM_IMP_API
#endif
#ifdef _WIN64
@ -67,7 +61,6 @@ typedef unsigned long tsrm_uintptr_t;
#endif
typedef int ts_rsrc_id;
typedef tsrm_uintptr_t ts_rsrc_offset;
/* Define THREAD_T and MUTEX_T */
#ifdef TSRM_WIN32
@ -101,88 +94,21 @@ typedef struct {
#include <signal.h>
#endif
typedef void (*ts_allocate_ctor)(void *, void ***);
typedef void (*ts_allocate_dtor)(void *, void ***);
#define THREAD_HASH_OF(thr,ts) (unsigned long)thr%(unsigned long)ts
#ifdef __cplusplus
extern "C" {
#endif
#ifdef USE___THREAD
# ifdef TSRM_WIN32
# define TSRM_TLS __declspec(thread)
# else
# define TSRM_TLS __thread
# endif
#define TSRMG(id, type, element) \
((type)((tsrm_uintptr_t) get_tsrm_ls_cache() + id##_offset))->element
#define TSRMLS_INIT() do { \
void *cache = (void *) ts_resource_ex(0, NULL); \
set_tsrm_ls_cache(&cache); \
} while (0)
#define TSRMLS_FETCH()
#define TSRMLS_FETCH_FROM_CTX(ctx)
#define TSRMLS_SET_CTX(ctx)
#define TSRMLS_D void
#define TSRMLS_DC
#define TSRMLS_C
#define TSRMLS_CC
#else /* USE___THREAD */
#define TSRMG(id, type, element) \
((type)(*(tsrm_uintptr_t *)tsrm_ls + id##_offset))->element
#define TSRMLS_INIT() TSRMLS_FETCH()
#define TSRMLS_FETCH() void **tsrm_ls = (void **) ts_resource_ex(0, NULL);
#define TSRMLS_FETCH_FROM_CTX(ctx) void **tsrm_ls = (void **) ctx
#define TSRMLS_SET_CTX(ctx) ctx = (void **) tsrm_ls
#define TSRMLS_D void **tsrm_ls
#define TSRMLS_DC , TSRMLS_D
#define TSRMLS_C tsrm_ls
#define TSRMLS_CC , TSRMLS_C
#define PASS_TSRMLS 1
#endif /* USE___THREAD */
#define TSRMG_DHE(type, id) \
TSRM_EXP_API extern ts_rsrc_id id; \
TSRM_EXP_API extern ts_rsrc_offset id##_offset
#define TSRMG_DE(type, id) \
TSRM_EXP_API ts_rsrc_id id; \
TSRM_EXP_API ts_rsrc_offset id##_offset
#define TSRMG_DH(type, id) \
TSRM_API extern ts_rsrc_id id; \
TSRM_API extern ts_rsrc_offset id##_offset
#define TSRMG_D(type, id) \
TSRM_API ts_rsrc_id id; \
TSRM_API ts_rsrc_offset id##_offset
#define TSRMG_ALLOCATE(id, size, ctor, dtor) \
TSRMG_ALLOCATE_EX(id, id##_offset, size, ctor, dtor);
#define TSRMG_ALLOCATE_EX(id, offset, size, ctor, dtor) \
ts_allocate_id(&(id), &(offset), (size), (ctor), (dtor));
#define TSRM_SHUFFLE_RSRC_ID(rsrc_id) ((rsrc_id)+1)
#define TSRM_UNSHUFFLE_RSRC_ID(rsrc_id) ((rsrc_id)-1)
typedef void (*ts_allocate_ctor)(void * TSRMLS_DC);
typedef void (*ts_allocate_dtor)(void * TSRMLS_DC);
/* startup/shutdown */
TSRM_API int tsrm_startup(int expected_threads, int expected_resources, int debug_level, char *debug_filename);
TSRM_API void tsrm_shutdown(void);
/* allocates a new thread-safe-resource id */
TSRM_API ts_rsrc_id ts_allocate_id(ts_rsrc_id *rsrc_id, ts_rsrc_offset *rsrc_offset, size_t size, ts_allocate_ctor ctor, ts_allocate_dtor dtor);
TSRM_API ts_rsrc_id ts_allocate_id(ts_rsrc_id *rsrc_id, size_t size, ts_allocate_ctor ctor, ts_allocate_dtor dtor);
/* fetches the requested resource for the current thread */
TSRM_API void *ts_resource_ex(ts_rsrc_id id, THREAD_T *th_id);
@ -203,8 +129,9 @@ TSRM_API void ts_free_id(ts_rsrc_id id);
#define TSRM_ERROR_LEVEL_CORE 2
#define TSRM_ERROR_LEVEL_INFO 3
typedef void (*tsrm_thread_begin_func_t)(THREAD_T thread_id TSRMLS_DC);
typedef void (*tsrm_thread_end_func_t)(THREAD_T thread_id TSRMLS_DC);
typedef void (*tsrm_thread_begin_func_t)(THREAD_T thread_id, void ***tsrm_ls);
typedef void (*tsrm_thread_end_func_t)(THREAD_T thread_id, void ***tsrm_ls);
TSRM_API int tsrm_error(int level, const char *format, ...);
TSRM_API void tsrm_error_set(int level, char *debug_filename);
@ -228,8 +155,19 @@ TSRM_API void *tsrm_new_interpreter_context(void);
TSRM_API void *tsrm_set_interpreter_context(void *new_ctx);
TSRM_API void tsrm_free_interpreter_context(void *context);
TSRM_API void *get_tsrm_ls_cache(void);
TSRM_API void set_tsrm_ls_cache(void **tsrm_ls_cache);
TSRM_API inline void *tsrm_get_ls_cache(void);
#define TSRM_SHUFFLE_RSRC_ID(rsrc_id) ((rsrc_id)+1)
#define TSRM_UNSHUFFLE_RSRC_ID(rsrc_id) ((rsrc_id)-1)
#define TSRMLS_FETCH() void ***tsrm_ls = (void ***) ts_resource_ex(0, NULL)
#define TSRMLS_FETCH_FROM_CTX(ctx) void ***tsrm_ls = (void ***) ctx
#define TSRMLS_SET_CTX(ctx) ctx = (void ***) tsrm_get_ls_cache()
#define TSRMG(id, type, element) (((type) (*((void ***) tsrm_get_ls_cache()))[TSRM_UNSHUFFLE_RSRC_ID(id)])->element)
#define TSRMLS_D
#define TSRMLS_DC
#define TSRMLS_C
#define TSRMLS_CC
#ifdef __cplusplus
}
@ -237,7 +175,6 @@ TSRM_API void set_tsrm_ls_cache(void **tsrm_ls_cache);
#else /* non ZTS */
#define TSRMLS_INIT()
#define TSRMLS_FETCH()
#define TSRMLS_FETCH_FROM_CTX(ctx)
#define TSRMLS_SET_CTX(ctx)

5
TSRM/configure.in
View File

@ -12,11 +12,10 @@ AH_TOP([
])
sinclude(tsrm.m4)
TSRM_BASIC_CHECKS
TSRM_THREADS_CHECKS
TSRM___THREAD_CHECKS
AM_PROG_LIBTOOL
if test "$enable_debug" != "yes"; then
AM_SET_LIBTOOL_VARIABLE([--silent])

68
TSRM/tsrm.m4
View File

@ -21,72 +21,6 @@ AC_DEFUN([TSRM_CHECK_GCC_ARG],[
fi
])
AC_DEFUN([TSRM___THREAD_CHECKS],[
AC_ARG_WITH(tsrm-native-tls,
[ --with-tsrm-native-tls
Use native TLS],[
USE___THREAD=yes
],[
USE___THREAD=no
])
if test $USE___THREAD = yes; then
AC_CACHE_CHECK([for __thread specifier], ac_cv_tsrm_have___thread, [
AC_TRY_RUN([
__thread int foo = 42;
int main() {
return foo - 42;
}
],[
ac_cv_tsrm_have___thread=yes
],[
ac_cv_tsrm_have___thread=no
])
])
AC_MSG_CHECKING(wether to use native TLS)
if test $ac_cv_tsrm_have___thread = yes; then
AC_DEFINE(USE___THREAD, 1, [wether to use native TLS])
else
AC_MSG_ERROR([__thread specifier not available])
fi
AC_MSG_RESULT(yes)
fi
])
dnl test and set the memory alignment
AC_DEFUN([TSRM_MM_ALIGN_CHECK], [
AC_CACHE_CHECK([for MM alignment], ac_cv_tsrm_mm_align, [
AC_TRY_RUN([
#include <stdio.h>
typedef union _mm_align_test {
void *ptr;
double dbl;
long lng;
} mm_align_test;
#if (defined (__GNUC__) && __GNUC__ >= 2)
# define TSRM_MM_ALIGNMENT (__alignof__ (mm_align_test))
#else
# define TSRM_MM_ALIGNMENT (sizeof(mm_align_test))
#endif
int main()
{
FILE *fp;
fp = fopen("conftest.tsrm", "w");
fprintf(fp, "%d\n", TSRM_MM_ALIGNMENT);
fclose(fp);
return 0;
}
],[
ac_cv_tsrm_mm_align=`cat conftest.tsrm | cut -d ' ' -f 1`
])
])
AC_DEFINE_UNQUOTED(TSRM_MM_ALIGNMENT, $ac_cv_tsrm_mm_align, [ ])
])
AC_DEFUN([TSRM_BASIC_CHECKS],[
AC_REQUIRE([AC_PROG_CC])dnl
@ -95,7 +29,7 @@ AC_REQUIRE([AC_PROG_CC_C_O])dnl
AC_REQUIRE([AC_PROG_RANLIB])dnl
AC_CHECK_HEADERS(stdarg.h)
TSRM_MM_ALIGN_CHECK()
AC_CHECK_FUNCS(sigprocmask)
])

4
TSRM/tsrm_win32.c
View File

@ -35,7 +35,7 @@
#include "zend_virtual_cwd.h"
#ifdef ZTS
TSRMG_D(win32_globals, win32_globals_id);
static ts_rsrc_id win32_globals_id;
#else
static tsrm_win32_globals win32_globals;
#endif
@ -90,7 +90,7 @@ static void tsrm_win32_dtor(tsrm_win32_globals *globals TSRMLS_DC)
TSRM_API void tsrm_win32_startup(void)
{
#ifdef ZTS
TSRMG_ALLOCATE(win32_globals_id, sizeof(tsrm_win32_globals), (ts_allocate_ctor)tsrm_win32_ctor, (ts_allocate_dtor)tsrm_win32_dtor);
ts_allocate_id(&win32_globals_id, sizeof(tsrm_win32_globals), (ts_allocate_ctor)tsrm_win32_ctor, (ts_allocate_ctor)tsrm_win32_dtor);
#else
tsrm_win32_ctor(&win32_globals TSRMLS_CC);
#endif

1
TSRM/tsrm_win32.h
View File

@ -69,7 +69,6 @@ typedef struct {
#ifdef ZTS
# define TWG(v) TSRMG(win32_globals_id, tsrm_win32_globals *, v)
TSRMG_DH(win32_globals, win32_globals_id);
#else
# define TWG(v) (win32_globals.v)
#endif

16
Zend/zend.c
View File

@ -113,8 +113,8 @@ ZEND_INI_END()
#ifdef ZTS
TSRMG_D(zend_compiler_globals, compiler_globals_id);
TSRMG_D(zend_executor_globals, executor_globals_id);
ZEND_API int compiler_globals_id;
ZEND_API int executor_globals_id;
static HashTable *global_function_table = NULL;
static HashTable *global_class_table = NULL;
static HashTable *global_constants_table = NULL;
@ -578,8 +578,8 @@ int zend_startup(zend_utility_functions *utility_functions, char **extensions TS
#ifdef ZTS
zend_compiler_globals *compiler_globals;
zend_executor_globals *executor_globals;
TSRMG_DH(zend_ini_scanner_globals, ini_scanner_globals_id);
TSRMG_DH(zend_php_scanner_globals, language_scanner_globals_id);
extern ZEND_API ts_rsrc_id ini_scanner_globals_id;
extern ZEND_API ts_rsrc_id language_scanner_globals_id;
#else
extern zend_ini_scanner_globals ini_scanner_globals;
extern zend_php_scanner_globals language_scanner_globals;
@ -652,10 +652,10 @@ int zend_startup(zend_utility_functions *utility_functions, char **extensions TS
zend_init_rsrc_list_dtors();
#ifdef ZTS
TSRMG_ALLOCATE(compiler_globals_id, sizeof(zend_compiler_globals), (ts_allocate_ctor) compiler_globals_ctor, (ts_allocate_dtor) compiler_globals_dtor);
TSRMG_ALLOCATE(executor_globals_id, sizeof(zend_executor_globals), (ts_allocate_ctor) executor_globals_ctor, (ts_allocate_dtor) executor_globals_dtor);
TSRMG_ALLOCATE(language_scanner_globals_id, sizeof(zend_php_scanner_globals), (ts_allocate_ctor) php_scanner_globals_ctor, NULL);
TSRMG_ALLOCATE(ini_scanner_globals_id, sizeof(zend_ini_scanner_globals), (ts_allocate_ctor) ini_scanner_globals_ctor, NULL);
ts_allocate_id(&compiler_globals_id, sizeof(zend_compiler_globals), (ts_allocate_ctor) compiler_globals_ctor, (ts_allocate_dtor) compiler_globals_dtor);
ts_allocate_id(&executor_globals_id, sizeof(zend_executor_globals), (ts_allocate_ctor) executor_globals_ctor, (ts_allocate_dtor) executor_globals_dtor);
ts_allocate_id(&language_scanner_globals_id, sizeof(zend_php_scanner_globals), (ts_allocate_ctor) php_scanner_globals_ctor, NULL);
ts_allocate_id(&ini_scanner_globals_id, sizeof(zend_ini_scanner_globals), (ts_allocate_ctor) ini_scanner_globals_ctor, NULL);
compiler_globals = ts_resource(compiler_globals_id);
executor_globals = ts_resource(executor_globals_id);

5
Zend/zend.h
View File

@ -71,11 +71,6 @@ void zend_error_noreturn(int type, const char *format, ...) ZEND_NORETURN;
# define zend_error_noreturn zend_error
#endif
#ifdef ZTS
TSRMG_DH(zend_compiler_globals, compiler_globals_id);
TSRMG_DH(zend_executor_globals, executor_globals_id);
#endif
/* overloaded elements data types */
#define OE_IS_ARRAY (1<<0)
#define OE_IS_OBJECT (1<<1)

2
Zend/zend_API.c
View File

@ -1876,7 +1876,7 @@ ZEND_API int zend_startup_module_ex(zend_module_entry *module TSRMLS_DC) /* {{{
/* Initialize module globals */
if (module->globals_size) {
#ifdef ZTS
TSRMG_ALLOCATE_EX((*module->globals_id_ptr), (*module->globals_offset), module->globals_size, module->globals_ctor, module->globals_dtor);
ts_allocate_id(module->globals_id_ptr, module->globals_size, (ts_allocate_ctor) module->globals_ctor, (ts_allocate_dtor) module->globals_dtor);
#else
if (module->globals_ctor) {
module->globals_ctor(module->globals_ptr TSRMLS_CC);

6
Zend/zend_API.h
View File

@ -145,11 +145,11 @@ typedef struct _zend_fcall_info_cache {
#ifdef ZTS
#define ZEND_DECLARE_MODULE_GLOBALS(module_name) \
TSRMG_DE(zend_##module_name##_globals, module_name##_globals_id);
ts_rsrc_id module_name##_globals_id;
#define ZEND_EXTERN_MODULE_GLOBALS(module_name) \
TSRMG_DH(zend_##module_name##_globals, module_name##_globals_id);
extern ts_rsrc_id module_name##_globals_id;
#define ZEND_INIT_MODULE_GLOBALS(module_name, globals_ctor, globals_dtor) \
TSRMG_ALLOCATE(module_name##_globals_id, sizeof(zend_##module_name##_globals), (ts_allocate_ctor) globals_ctor, (ts_allocate_dtor) globals_dtor);
ts_allocate_id(&module_name##_globals_id, sizeof(zend_##module_name##_globals), (ts_allocate_ctor) globals_ctor, (ts_allocate_dtor) globals_dtor);
#else

4
Zend/zend_alloc.c
View File

@ -2008,7 +2008,7 @@ typedef struct _zend_alloc_globals {
} zend_alloc_globals;
#ifdef ZTS
TSRMG_D(zend_alloc_globals, alloc_globals_id);
static int alloc_globals_id;
# define AG(v) TSRMG(alloc_globals_id, zend_alloc_globals *, v)
#else
# define AG(v) (alloc_globals.v)
@ -2340,7 +2340,7 @@ static void alloc_globals_dtor(zend_alloc_globals *alloc_globals TSRMLS_DC)
ZEND_API void start_memory_manager(TSRMLS_D)
{
#ifdef ZTS
TSRMG_ALLOCATE(alloc_globals_id, sizeof(zend_alloc_globals), (ts_allocate_ctor) alloc_globals_ctor, (ts_allocate_dtor) alloc_globals_dtor);
ts_allocate_id(&alloc_globals_id, sizeof(zend_alloc_globals), (ts_allocate_ctor) alloc_globals_ctor, (ts_allocate_dtor) alloc_globals_dtor);
#else
alloc_globals_ctor(&alloc_globals);
#endif

6
Zend/zend_compile.c
View File

@ -3085,7 +3085,11 @@ static void zend_free_foreach_and_switch_variables(TSRMLS_D) /* {{{ */
opnum_start = get_next_op_number(CG(active_op_array));
zend_stack_apply(&CG(loop_var_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element)) generate_free_loop_var);
#ifdef ZTS
zend_stack_apply_with_argument(&CG(loop_var_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element, void *)) generate_free_loop_var, NULL);
#else
zend_stack_apply(&CG(loop_var_stack), ZEND_STACK_APPLY_TOPDOWN, (int (*)(void *element)) generate_free_loop_var);
#endif
opnum_end = get_next_op_number(CG(active_op_array));

23
Zend/zend_execute_API.c
View File

@ -1178,17 +1178,19 @@ static LRESULT CALLBACK zend_timeout_WndProc(HWND hWnd, UINT message, WPARAM wPa
KillTimer(timeout_window, wParam);
} else {
#ifdef ZTS
void *tsrm_ls_cache;
void ***tsrm_ls;
#endif
SetTimer(timeout_window, wParam, lParam*1000, NULL);
#ifdef ZTS
tsrm_ls_cache = get_tsrm_ls_cache();
if (!tsrm_ls_cache) {
tsrm_ls = ts_resource_ex(0, &wParam);
if (!tsrm_ls) {
/* shouldn't normally happen */
break;
}
#endif
EG(timed_out) = 0;
/* XXX this won't work with TLS enabled, EG is on a different thread.
But nothing happened anyway, no timeout here. */
/* EG(timed_out) = 0; */
}
break;
case WM_UNREGISTER_ZEND_TIMEOUT:
@ -1197,16 +1199,19 @@ static LRESULT CALLBACK zend_timeout_WndProc(HWND hWnd, UINT message, WPARAM wPa
break;
case WM_TIMER: {
#ifdef ZTS
void *tsrm_ls_cache;
void ***tsrm_ls;
tsrm_ls_cache = get_tsrm_ls_cache();
if (!tsrm_ls_cache) {
tsrm_ls = ts_resource_ex(0, &wParam);
if (!tsrm_ls) {
/* Thread died before receiving its timeout? */
break;
}
#endif
KillTimer(timeout_window, wParam);
EG(timed_out) = 1;
/* XXX this won't work with TLS enabled, EG is on a different thread.
Maybe an ide were to throw the timeout window right from here. */
/*EG(timed_out) = 1; */
}
break;
default:
@ -1280,6 +1285,8 @@ void zend_shutdown_timeout_thread(void) /* {{{ */
void zend_set_timeout(zend_long seconds, int reset_signals) /* {{{ */
{
TSRMLS_FETCH();
EG(timeout_seconds) = seconds;
#ifdef ZEND_WIN32

4
Zend/zend_gc.c
View File

@ -26,7 +26,7 @@
#define GC_ROOT_BUFFER_MAX_ENTRIES 10001
#ifdef ZTS
TSRMG_D(zend_gc_globals, gc_globals_id);
ZEND_API int gc_globals_id;
#else
ZEND_API zend_gc_globals gc_globals;
#endif
@ -82,7 +82,7 @@ static void gc_globals_ctor_ex(zend_gc_globals *gc_globals TSRMLS_DC)
ZEND_API void gc_globals_ctor(TSRMLS_D)
{
#ifdef ZTS
TSRMG_ALLOCATE(gc_globals_id, sizeof(zend_gc_globals), (ts_allocate_ctor) gc_globals_ctor_ex, (ts_allocate_dtor) root_buffer_dtor);
ts_allocate_id(&gc_globals_id, sizeof(zend_gc_globals), (ts_allocate_ctor) gc_globals_ctor_ex, (ts_allocate_dtor) root_buffer_dtor);
#else
gc_globals_ctor_ex(&gc_globals);
#endif

2
Zend/zend_gc.h
View File

@ -110,7 +110,7 @@ typedef struct _zend_gc_globals {
#ifdef ZTS
BEGIN_EXTERN_C()
TSRMG_DH(zend_gc_globals, gc_globals_id);
ZEND_API extern int gc_globals_id;
END_EXTERN_C()
#define GC_G(v) TSRMG(gc_globals_id, zend_gc_globals *, v)
#else

4
Zend/zend_globals.h
View File

@ -44,8 +44,8 @@
#ifdef ZTS
BEGIN_EXTERN_C()
TSRMG_DH(zend_compiler_globals, compiler_globals_id);
TSRMG_DH(zend_executor_globals, executor_globals_id);
ZEND_API extern int compiler_globals_id;
ZEND_API extern int executor_globals_id;
END_EXTERN_C()
#endif

10
Zend/zend_globals_macros.h
View File

@ -36,12 +36,8 @@ BEGIN_EXTERN_C()
# define CG(v) (compiler_globals.v)
extern ZEND_API struct _zend_compiler_globals compiler_globals;
#endif
int zendparse(void);
#ifdef PASS_TSRMLS
int zendparse(void *compiler_globals);
#else
int zend_parse(void);
#endif
/* Executor */
#ifdef ZTS
@ -54,7 +50,7 @@ extern ZEND_API zend_executor_globals executor_globals;
/* Language Scanner */
#ifdef ZTS
# define LANG_SCNG(v) TSRMG(language_scanner_globals_id, zend_php_scanner_globals *, v)
TSRMG_DH(zend_php_scanner_globals, language_scanner_globals_id);
extern ZEND_API ts_rsrc_id language_scanner_globals_id;
#else
# define LANG_SCNG(v) (language_scanner_globals.v)
extern ZEND_API zend_php_scanner_globals language_scanner_globals;
@ -64,7 +60,7 @@ extern ZEND_API zend_php_scanner_globals language_scanner_globals;
/* INI Scanner */
#ifdef ZTS
# define INI_SCNG(v) TSRMG(ini_scanner_globals_id, zend_ini_scanner_globals *, v)
TSRMG_DH(zend_ini_scanner_globals, ini_scanner_globals_id);
extern ZEND_API ts_rsrc_id ini_scanner_globals_id;
#else
# define INI_SCNG(v) (ini_scanner_globals.v)
extern ZEND_API zend_ini_scanner_globals ini_scanner_globals;

2
Zend/zend_ini_parser.y
View File

@ -32,7 +32,7 @@
#define YYERROR_VERBOSE
#define YYSTYPE zval
#ifdef PASS_TSRMLS
#ifdef ZTS
#define YYPARSE_PARAM tsrm_ls
#define YYLEX_PARAM tsrm_ls
int ini_parse(void *arg);

2
Zend/zend_ini_scanner.c
View File

@ -103,7 +103,7 @@
/* Globals Macros */
#define SCNG INI_SCNG
#ifdef ZTS
TSRMG_D(zend_ini_scanner_globals, ini_scanner_globals_id);
ZEND_API ts_rsrc_id ini_scanner_globals_id;
#else
ZEND_API zend_ini_scanner_globals ini_scanner_globals;
#endif

2
Zend/zend_ini_scanner.l
View File

@ -101,7 +101,7 @@
/* Globals Macros */
#define SCNG INI_SCNG
#ifdef ZTS
TSRMG_D(zend_ini_scanner_globals, ini_scanner_globals_id);
ZEND_API ts_rsrc_id ini_scanner_globals_id;
#else
ZEND_API zend_ini_scanner_globals ini_scanner_globals;
#endif

4
Zend/zend_language_parser.y
View File

@ -49,10 +49,6 @@ static YYSIZE_T zend_yytnamerr(char*, const char*);
%expect 2
%code requires {
#ifdef PASS_TSRMLS
# define YYPARSE_PARAM tsrm_ls
# define YYLEX_PARAM tsrm_ls
#endif
}
%destructor { zend_ast_destroy($$); } <ast>

2
Zend/zend_language_scanner.c
View File

@ -90,7 +90,7 @@
/* Globals Macros */
#define SCNG LANG_SCNG
#ifdef ZTS
TSRMG_D(zend_php_scanner_globals, language_scanner_globals_id);
ZEND_API ts_rsrc_id language_scanner_globals_id;
#else
ZEND_API zend_php_scanner_globals language_scanner_globals;
#endif

2
Zend/zend_language_scanner.l
View File

@ -88,7 +88,7 @@
/* Globals Macros */
#define SCNG LANG_SCNG
#ifdef ZTS
TSRMG_D(zend_php_scanner_globals, language_scanner_globals_id);
ZEND_API ts_rsrc_id language_scanner_globals_id;
#else
ZEND_API zend_php_scanner_globals language_scanner_globals;
#endif

7
Zend/zend_modules.h
View File

@ -50,14 +50,10 @@
#define STANDARD_MODULE_PROPERTIES_EX 0, 0, NULL, 0, ZEND_MODULE_BUILD_ID
#ifdef ZTS
#define NO_MODULE_GLOBALS 0, NULL, NULL, NULL, NULL
#else
#define NO_MODULE_GLOBALS 0, NULL, NULL, NULL
#endif
#ifdef ZTS
# define ZEND_MODULE_GLOBALS(module_name) sizeof(zend_##module_name##_globals), &module_name##_globals_id, &module_name##_globals_id_offset
# define ZEND_MODULE_GLOBALS(module_name) sizeof(zend_##module_name##_globals), &module_name##_globals_id
#else
# define ZEND_MODULE_GLOBALS(module_name) sizeof(zend_##module_name##_globals), &module_name##_globals
#endif
@ -92,7 +88,6 @@ struct _zend_module_entry {
size_t globals_size;
#ifdef ZTS
ts_rsrc_id* globals_id_ptr;
ts_rsrc_offset* globals_offset;
#else
void* globals_ptr;
#endif

28
Zend/zend_operators.c
View File

@ -2159,7 +2159,19 @@ try_again:
}
break;
case IS_OBJECT:
if (Z_OBJ_HANDLER_P(op1, do_operation)) {
if (Z_OBJ_HANDLER_P(op1, get)
&& Z_OBJ_HANDLER_P(op1, set)) {
/* proxy object */
zval rv;
zval *val;
TSRMLS_FETCH();
val = Z_OBJ_HANDLER_P(op1, get)(op1, &rv TSRMLS_CC);
Z_ADDREF_P(val);
fast_increment_function(val);
Z_OBJ_HANDLER_P(op1, set)(op1, val TSRMLS_CC);
zval_ptr_dtor(val);
} else if (Z_OBJ_HANDLER_P(op1, do_operation)) {
zval op2;
int res;
TSRMLS_FETCH();
@ -2222,7 +2234,19 @@ try_again:
}
break;
case IS_OBJECT:
if (Z_OBJ_HANDLER_P(op1, do_operation)) {
if (Z_OBJ_HANDLER_P(op1, get)
&& Z_OBJ_HANDLER_P(op1, set)) {
/* proxy object */
zval rv;
zval *val;
TSRMLS_FETCH();
val = Z_OBJ_HANDLER_P(op1, get)(op1, &rv TSRMLS_CC);
Z_ADDREF_P(val);
fast_decrement_function(val);
Z_OBJ_HANDLER_P(op1, set)(op1, val TSRMLS_CC);
zval_ptr_dtor(val);
} else if (Z_OBJ_HANDLER_P(op1, do_operation)) {
zval op2;
int res;
TSRMLS_FETCH();

5
Zend/zend_stack.c
View File

@ -124,6 +124,7 @@ ZEND_API void zend_stack_apply(zend_stack *stack, int type, int (*apply_function
}
}
ZEND_API void zend_stack_apply_with_argument(zend_stack *stack, int type, int (*apply_function)(void *element, void *arg), void *arg)
{
int i;
@ -131,14 +132,14 @@ ZEND_API void zend_stack_apply_with_argument(zend_stack *stack, int type, int (*
switch (type) {
case ZEND_STACK_APPLY_TOPDOWN:
for (i=stack->top-1; i>=0; i--) {
if (apply_function(ZEND_STACK_ELEMENT(stack, i), arg)) {
if (apply_function(ZEND_STACK_ELEMENT(stack, i), arg)) {
break;
}
}
break;
case ZEND_STACK_APPLY_BOTTOMUP:
for (i=0; i<stack->top; i++) {
if (apply_function(ZEND_STACK_ELEMENT(stack, i), arg)) {
if (apply_function(ZEND_STACK_ELEMENT(stack, i), arg)) {
break;
}
}

4
Zend/zend_virtual_cwd.c
View File

@ -76,7 +76,7 @@ MUTEX_T cwd_mutex;
#endif
#ifdef ZTS
TSRMG_D(virtual_cwd_globals, cwd_globals_id);
ts_rsrc_id cwd_globals_id;
#else
virtual_cwd_globals cwd_globals;
#endif
@ -475,7 +475,7 @@ CWD_API void virtual_cwd_startup(void) /* {{{ */
main_cwd_state.cwd = strdup(cwd);
#ifdef ZTS
TSRMG_ALLOCATE(cwd_globals_id, sizeof(virtual_cwd_globals), (ts_allocate_ctor) cwd_globals_ctor, (ts_allocate_dtor) cwd_globals_dtor);
ts_allocate_id(&cwd_globals_id, sizeof(virtual_cwd_globals), (ts_allocate_ctor) cwd_globals_ctor, (ts_allocate_dtor) cwd_globals_dtor);
#else
cwd_globals_ctor(&cwd_globals TSRMLS_CC);
#endif

2
Zend/zend_virtual_cwd.h
View File

@ -236,7 +236,7 @@ typedef struct _virtual_cwd_globals {
} virtual_cwd_globals;
#ifdef ZTS
TSRMG_DH(virtual_cwd_globals, cwd_globals_id);
extern ts_rsrc_id cwd_globals_id;
# define CWDG(v) TSRMG(cwd_globals_id, virtual_cwd_globals *, v)
#else
extern virtual_cwd_globals cwd_globals;

81
Zend/zend_vm_def.h
View File

@ -883,7 +883,6 @@ ZEND_VM_HANDLER(34, ZEND_PRE_INC, VAR|CV, ANY)
if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
FREE_OP1_VAR_PTR();
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
@ -891,19 +890,7 @@ ZEND_VM_HANDLER(34, ZEND_PRE_INC, VAR|CV, ANY)
ZVAL_DEREF(var_ptr);
SEPARATE_ZVAL_NOREF(var_ptr);
if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
&& Z_OBJ_HANDLER_P(var_ptr, get)
&& Z_OBJ_HANDLER_P(var_ptr, set)) {
/* proxy object */
zval rv;
zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
Z_ADDREF_P(val);
fast_increment_function(val);
Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC);
zval_ptr_dtor(val);
} else {
increment_function(var_ptr);
}
increment_function(var_ptr);
if (RETURN_VALUE_USED(opline)) {
ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@ -939,7 +926,6 @@ ZEND_VM_HANDLER(35, ZEND_PRE_DEC, VAR|CV, ANY)
if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
FREE_OP1_VAR_PTR();
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
@ -947,19 +933,7 @@ ZEND_VM_HANDLER(35, ZEND_PRE_DEC, VAR|CV, ANY)
ZVAL_DEREF(var_ptr);
SEPARATE_ZVAL_NOREF(var_ptr);
if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
&& Z_OBJ_HANDLER_P(var_ptr, get)
&& Z_OBJ_HANDLER_P(var_ptr, set)) {
/* proxy object */
zval rv;
zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
Z_ADDREF_P(val);
fast_decrement_function(val);
Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC);
zval_ptr_dtor(val);
} else {
decrement_function(var_ptr);
}
decrement_function(var_ptr);
if (RETURN_VALUE_USED(opline)) {
ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@ -974,7 +948,7 @@ ZEND_VM_HANDLER(36, ZEND_POST_INC, VAR|CV, ANY)
{
USE_OPLINE
zend_free_op free_op1;
zval *var_ptr, *retval;
zval *var_ptr;
SAVE_OPLINE();
var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
@ -991,34 +965,19 @@ ZEND_VM_HANDLER(36, ZEND_POST_INC, VAR|CV, ANY)
if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
ZVAL_NULL(EX_VAR(opline->result.var));
FREE_OP1_VAR_PTR();
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
retval = EX_VAR(opline->result.var);
if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
var_ptr = Z_REFVAL_P(var_ptr);
ZVAL_DUP(retval, var_ptr);
ZVAL_DUP(EX_VAR(opline->result.var), var_ptr);
} else {
ZVAL_DUP(retval, var_ptr);
SEPARATE_ZVAL_NOREF(var_ptr);
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
zval_opt_copy_ctor(var_ptr);
}
if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
&& Z_OBJ_HANDLER_P(var_ptr, get)
&& Z_OBJ_HANDLER_P(var_ptr, set)) {
/* proxy object */
zval rv;
zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
Z_ADDREF_P(val);
fast_increment_function(val);
Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC);
zval_ptr_dtor(val);
} else {
increment_function(var_ptr);
}
increment_function(var_ptr);
FREE_OP1_VAR_PTR();
CHECK_EXCEPTION();
@ -1029,7 +988,7 @@ ZEND_VM_HANDLER(37, ZEND_POST_DEC, VAR|CV, ANY)
{
USE_OPLINE
zend_free_op free_op1;
zval *var_ptr, *retval;
zval *var_ptr;
SAVE_OPLINE();
var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
@ -1046,34 +1005,19 @@ ZEND_VM_HANDLER(37, ZEND_POST_DEC, VAR|CV, ANY)
if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
ZVAL_NULL(EX_VAR(opline->result.var));
FREE_OP1_VAR_PTR();
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
retval = EX_VAR(opline->result.var);
if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
var_ptr = Z_REFVAL_P(var_ptr);
ZVAL_DUP(retval, var_ptr);
ZVAL_DUP(EX_VAR(opline->result.var), var_ptr);
} else {
ZVAL_DUP(retval, var_ptr);
SEPARATE_ZVAL_NOREF(var_ptr);
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
zval_opt_copy_ctor(var_ptr);
}
if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
&& Z_OBJ_HANDLER_P(var_ptr, get)
&& Z_OBJ_HANDLER_P(var_ptr, set)) {
/* proxy object */
zval rv;
zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
Z_ADDREF_P(val);
fast_decrement_function(val);
Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC);
zval_ptr_dtor(val);
} else {
decrement_function(var_ptr);
}
decrement_function(var_ptr);
FREE_OP1_VAR_PTR();
CHECK_EXCEPTION();
@ -1647,7 +1591,6 @@ ZEND_VM_HANDLER(147, ZEND_ASSIGN_DIM, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
FREE_OP_VAR_PTR(free_op_data2);
} else {
value = zend_assign_to_variable(variable_ptr, value, (opline+1)->op1_type TSRMLS_CC);
if ((opline+1)->op1_type == IS_VAR) {

170
Zend/zend_vm_execute.h
View File

@ -15335,7 +15335,6 @@ static int ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
@ -15343,19 +15342,7 @@ static int ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
ZVAL_DEREF(var_ptr);
SEPARATE_ZVAL_NOREF(var_ptr);
if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
&& Z_OBJ_HANDLER_P(var_ptr, get)
&& Z_OBJ_HANDLER_P(var_ptr, set)) {
/* proxy object */
zval rv;
zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
Z_ADDREF_P(val);
fast_increment_function(val);
Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC);
zval_ptr_dtor(val);
} else {
increment_function(var_ptr);
}
increment_function(var_ptr);
if (RETURN_VALUE_USED(opline)) {
ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@ -15391,7 +15378,6 @@ static int ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
@ -15399,19 +15385,7 @@ static int ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
ZVAL_DEREF(var_ptr);
SEPARATE_ZVAL_NOREF(var_ptr);
if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
&& Z_OBJ_HANDLER_P(var_ptr, get)
&& Z_OBJ_HANDLER_P(var_ptr, set)) {
/* proxy object */
zval rv;
zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
Z_ADDREF_P(val);
fast_decrement_function(val);
Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC);
zval_ptr_dtor(val);
} else {
decrement_function(var_ptr);
}
decrement_function(var_ptr);
if (RETURN_VALUE_USED(opline)) {
ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@ -15426,7 +15400,7 @@ static int ZEND_FASTCALL ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
{
USE_OPLINE
zend_free_op free_op1;
zval *var_ptr, *retval;
zval *var_ptr;
SAVE_OPLINE();
var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
@ -15443,34 +15417,19 @@ static int ZEND_FASTCALL ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
ZVAL_NULL(EX_VAR(opline->result.var));
if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
retval = EX_VAR(opline->result.var);
if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
var_ptr = Z_REFVAL_P(var_ptr);
ZVAL_DUP(retval, var_ptr);
ZVAL_DUP(EX_VAR(opline->result.var), var_ptr);
} else {
ZVAL_DUP(retval, var_ptr);
SEPARATE_ZVAL_NOREF(var_ptr);
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
zval_opt_copy_ctor(var_ptr);
}
if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
&& Z_OBJ_HANDLER_P(var_ptr, get)
&& Z_OBJ_HANDLER_P(var_ptr, set)) {
/* proxy object */
zval rv;
zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
Z_ADDREF_P(val);
fast_increment_function(val);
Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC);
zval_ptr_dtor(val);
} else {
increment_function(var_ptr);
}
increment_function(var_ptr);
if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
CHECK_EXCEPTION();
@ -15481,7 +15440,7 @@ static int ZEND_FASTCALL ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
{
USE_OPLINE
zend_free_op free_op1;
zval *var_ptr, *retval;
zval *var_ptr;
SAVE_OPLINE();
var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
@ -15498,34 +15457,19 @@ static int ZEND_FASTCALL ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
ZVAL_NULL(EX_VAR(opline->result.var));
if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
retval = EX_VAR(opline->result.var);
if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
var_ptr = Z_REFVAL_P(var_ptr);
ZVAL_DUP(retval, var_ptr);
ZVAL_DUP(EX_VAR(opline->result.var), var_ptr);
} else {
ZVAL_DUP(retval, var_ptr);
SEPARATE_ZVAL_NOREF(var_ptr);
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
zval_opt_copy_ctor(var_ptr);
}
if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
&& Z_OBJ_HANDLER_P(var_ptr, get)
&& Z_OBJ_HANDLER_P(var_ptr, set)) {
/* proxy object */
zval rv;
zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
Z_ADDREF_P(val);
fast_decrement_function(val);
Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC);
zval_ptr_dtor(val);
} else {
decrement_function(var_ptr);
}
decrement_function(var_ptr);
if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
CHECK_EXCEPTION();
@ -18307,7 +18251,6 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAN
if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
FREE_OP_VAR_PTR(free_op_data2);
} else {
value = zend_assign_to_variable(variable_ptr, value, (opline+1)->op1_type TSRMLS_CC);
if ((opline+1)->op1_type == IS_VAR) {
@ -20523,7 +20466,6 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDL
if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
FREE_OP_VAR_PTR(free_op_data2);
} else {
value = zend_assign_to_variable(variable_ptr, value, (opline+1)->op1_type TSRMLS_CC);
if ((opline+1)->op1_type == IS_VAR) {
@ -22642,7 +22584,6 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDL
if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
FREE_OP_VAR_PTR(free_op_data2);
} else {
value = zend_assign_to_variable(variable_ptr, value, (opline+1)->op1_type TSRMLS_CC);
if ((opline+1)->op1_type == IS_VAR) {
@ -24278,7 +24219,6 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HA
if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
FREE_OP_VAR_PTR(free_op_data2);
} else {
value = zend_assign_to_variable(variable_ptr, value, (opline+1)->op1_type TSRMLS_CC);
if ((opline+1)->op1_type == IS_VAR) {
@ -26015,7 +25955,6 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLE
if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
FREE_OP_VAR_PTR(free_op_data2);
} else {
value = zend_assign_to_variable(variable_ptr, value, (opline+1)->op1_type TSRMLS_CC);
if ((opline+1)->op1_type == IS_VAR) {
@ -32664,7 +32603,6 @@ static int ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
@ -32672,19 +32610,7 @@ static int ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
ZVAL_DEREF(var_ptr);
SEPARATE_ZVAL_NOREF(var_ptr);
if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
&& Z_OBJ_HANDLER_P(var_ptr, get)
&& Z_OBJ_HANDLER_P(var_ptr, set)) {
/* proxy object */
zval rv;
zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
Z_ADDREF_P(val);
fast_increment_function(val);
Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC);
zval_ptr_dtor(val);
} else {
increment_function(var_ptr);
}
increment_function(var_ptr);
if (RETURN_VALUE_USED(opline)) {
ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@ -32719,7 +32645,6 @@ static int ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
@ -32727,19 +32652,7 @@ static int ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
ZVAL_DEREF(var_ptr);
SEPARATE_ZVAL_NOREF(var_ptr);
if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
&& Z_OBJ_HANDLER_P(var_ptr, get)
&& Z_OBJ_HANDLER_P(var_ptr, set)) {
/* proxy object */
zval rv;
zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
Z_ADDREF_P(val);
fast_decrement_function(val);
Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC);
zval_ptr_dtor(val);
} else {
decrement_function(var_ptr);
}
decrement_function(var_ptr);
if (RETURN_VALUE_USED(opline)) {
ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@ -32753,7 +32666,7 @@ static int ZEND_FASTCALL ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
{
USE_OPLINE
zval *var_ptr, *retval;
zval *var_ptr;
SAVE_OPLINE();
var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
@ -32770,34 +32683,19 @@ static int ZEND_FASTCALL ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
ZVAL_NULL(EX_VAR(opline->result.var));
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
retval = EX_VAR(opline->result.var);
if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
var_ptr = Z_REFVAL_P(var_ptr);
ZVAL_DUP(retval, var_ptr);
ZVAL_DUP(EX_VAR(opline->result.var), var_ptr);
} else {
ZVAL_DUP(retval, var_ptr);
SEPARATE_ZVAL_NOREF(var_ptr);
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
zval_opt_copy_ctor(var_ptr);
}
if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
&& Z_OBJ_HANDLER_P(var_ptr, get)
&& Z_OBJ_HANDLER_P(var_ptr, set)) {
/* proxy object */
zval rv;
zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
Z_ADDREF_P(val);
fast_increment_function(val);
Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC);
zval_ptr_dtor(val);
} else {
increment_function(var_ptr);
}
increment_function(var_ptr);
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
@ -32807,7 +32705,7 @@ static int ZEND_FASTCALL ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
{
USE_OPLINE
zval *var_ptr, *retval;
zval *var_ptr;
SAVE_OPLINE();
var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
@ -32824,34 +32722,19 @@ static int ZEND_FASTCALL ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
ZVAL_NULL(EX_VAR(opline->result.var));
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
retval = EX_VAR(opline->result.var);
if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
var_ptr = Z_REFVAL_P(var_ptr);
ZVAL_DUP(retval, var_ptr);
ZVAL_DUP(EX_VAR(opline->result.var), var_ptr);
} else {
ZVAL_DUP(retval, var_ptr);
SEPARATE_ZVAL_NOREF(var_ptr);
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
zval_opt_copy_ctor(var_ptr);
}
if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
&& Z_OBJ_HANDLER_P(var_ptr, get)
&& Z_OBJ_HANDLER_P(var_ptr, set)) {
/* proxy object */
zval rv;
zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
Z_ADDREF_P(val);
fast_decrement_function(val);
Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC);
zval_ptr_dtor(val);
} else {
decrement_function(var_ptr);
}
decrement_function(var_ptr);
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
@ -35370,7 +35253,6 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND
if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
FREE_OP_VAR_PTR(free_op_data2);
} else {
value = zend_assign_to_variable(variable_ptr, value, (opline+1)->op1_type TSRMLS_CC);
if ((opline+1)->op1_type == IS_VAR) {
@ -37428,7 +37310,6 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLE
if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
FREE_OP_VAR_PTR(free_op_data2);
} else {
value = zend_assign_to_variable(variable_ptr, value, (opline+1)->op1_type TSRMLS_CC);
if ((opline+1)->op1_type == IS_VAR) {
@ -39428,7 +39309,6 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLE
if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
FREE_OP_VAR_PTR(free_op_data2);
} else {
value = zend_assign_to_variable(variable_ptr, value, (opline+1)->op1_type TSRMLS_CC);
if ((opline+1)->op1_type == IS_VAR) {
@ -40944,7 +40824,6 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAN
if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
FREE_OP_VAR_PTR(free_op_data2);
} else {
value = zend_assign_to_variable(variable_ptr, value, (opline+1)->op1_type TSRMLS_CC);
if ((opline+1)->op1_type == IS_VAR) {
@ -42545,7 +42424,6 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER
if (RETURN_VALUE_USED(opline)) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
FREE_OP_VAR_PTR(free_op_data2);
} else {
value = zend_assign_to_variable(variable_ptr, value, (opline+1)->op1_type TSRMLS_CC);
if ((opline+1)->op1_type == IS_VAR) {

1
ext/date/php_date.h
View File

@ -197,7 +197,6 @@ ZEND_BEGIN_MODULE_GLOBALS(date)
ZEND_END_MODULE_GLOBALS(date)
#ifdef ZTS
TSRMG_DH(zend_date_globals, date_globals_id);
#define DATEG(v) TSRMG(date_globals_id, zend_date_globals *, v)
#else
#define DATEG(v) (date_globals.v)

4
ext/opcache/ZendAccelerator.c
View File

@ -89,7 +89,7 @@ ZEND_EXTENSION();
#ifndef ZTS
zend_accel_globals accel_globals;
#else
TSRMG_D(zend_accel_globals, accel_globals_id);
int accel_globals_id;
#endif
/* Points to the structure shared across all PHP processes */
@ -2270,7 +2270,7 @@ static int accel_startup(zend_extension *extension)
TSRMLS_FETCH();
#ifdef ZTS
TSRMG_ALLOCATE(accel_globals_id, sizeof(zend_accel_globals), (ts_allocate_ctor) accel_globals_ctor, (ts_allocate_dtor) accel_globals_dtor);
accel_globals_id = ts_allocate_id(&accel_globals_id, sizeof(zend_accel_globals), (ts_allocate_ctor) accel_globals_ctor, (ts_allocate_dtor) accel_globals_dtor);
#else
accel_globals_ctor(&accel_globals);
#endif

2
ext/opcache/ZendAccelerator.h
View File

@ -282,7 +282,7 @@ extern zend_accel_shared_globals *accel_shared_globals;
#ifdef ZTS
# define ZCG(v) TSRMG(accel_globals_id, zend_accel_globals *, v)
TSRMG_DH(zend_accel_globals, accel_globals_id);
extern int accel_globals_id;
#else
# define ZCG(v) (accel_globals.v)
extern zend_accel_globals accel_globals;

22
ext/pdo/pdo_sql_parser.c
View File

@ -1,5 +1,4 @@
/* Generated by re2c 0.13.5 */
#line 1 "ext/pdo/pdo_sql_parser.re"
/*
+----------------------------------------------------------------------+
| PHP Version 7 |
@ -47,11 +46,9 @@ static int scan(Scanner *s)
char *cursor = s->cur;
s->tok = cursor;
#line 55 "ext/pdo/pdo_sql_parser.re"
#line 55 "ext/pdo/pdo_sql_parser.c"
{
YYCTYPE yych;
unsigned int yyaccept = 0;
@ -79,9 +76,7 @@ yy3:
yych = *(YYMARKER = ++YYCURSOR);
if (yych >= 0x01) goto yy43;
yy4:
#line 63 "ext/pdo/pdo_sql_parser.re"
{ SKIP_ONE(PDO_PARSER_TEXT); }
#line 85 "ext/pdo/pdo_sql_parser.c"
yy5:
yyaccept = 0;
yych = *(YYMARKER = ++YYCURSOR);
@ -163,9 +158,7 @@ yy7:
default: goto yy8;
}
yy8:
#line 62 "ext/pdo/pdo_sql_parser.re"
{ RET(PDO_PARSER_BIND_POS); }
#line 169 "ext/pdo/pdo_sql_parser.c"
yy9:
++YYCURSOR;
switch ((yych = *YYCURSOR)) {
@ -173,9 +166,7 @@ yy9:
default: goto yy13;
}
yy10:
#line 65 "ext/pdo/pdo_sql_parser.re"
{ RET(PDO_PARSER_TEXT); }
#line 179 "ext/pdo/pdo_sql_parser.c"
yy11:
yych = *++YYCURSOR;
switch (yych) {
@ -210,9 +201,7 @@ yy14:
default: goto yy14;
}
yy16:
#line 64 "ext/pdo/pdo_sql_parser.re"
{ RET(PDO_PARSER_TEXT); }
#line 216 "ext/pdo/pdo_sql_parser.c"
yy17:
++YYCURSOR;
if (YYLIMIT <= YYCURSOR) YYFILL(1);
@ -290,9 +279,7 @@ yy29:
default: goto yy31;
}
yy31:
#line 60 "ext/pdo/pdo_sql_parser.re"
{ RET(PDO_PARSER_TEXT); }
#line 296 "ext/pdo/pdo_sql_parser.c"
yy32:
++YYCURSOR;
if (YYLIMIT <= YYCURSOR) YYFILL(1);
@ -364,9 +351,7 @@ yy32:
default: goto yy34;
}
yy34:
#line 61 "ext/pdo/pdo_sql_parser.re"
{ RET(PDO_PARSER_BIND); }
#line 370 "ext/pdo/pdo_sql_parser.c"
yy35:
++YYCURSOR;
if (YYLIMIT <= YYCURSOR) YYFILL(1);
@ -394,9 +379,7 @@ yy39:
goto yy37;
yy40:
++YYCURSOR;
#line 59 "ext/pdo/pdo_sql_parser.re"
{ RET(PDO_PARSER_TEXT); }
#line 400 "ext/pdo/pdo_sql_parser.c"
yy42:
++YYCURSOR;
if (YYLIMIT <= YYCURSOR) YYFILL(1);
@ -416,20 +399,17 @@ yy44:
goto yy42;
yy45:
++YYCURSOR;
#line 58 "ext/pdo/pdo_sql_parser.re"
{ RET(PDO_PARSER_TEXT); }
#line 422 "ext/pdo/pdo_sql_parser.c"
}
#line 66 "ext/pdo/pdo_sql_parser.re"
}
struct placeholder {
char *pos;
char *quoted; /* quoted value */
int len;
int bindno;
int qlen; /* quoted length of value */
char *quoted; /* quoted value */
int freeq;
struct placeholder *next;
};

2
ext/spl/php_spl.h
View File

@ -68,7 +68,7 @@ ZEND_END_MODULE_GLOBALS(spl)
#ifdef ZTS
# define SPL_G(v) TSRMG(spl_globals_id, zend_spl_globals *, v)
TSRMG_DH(zend_spl_globals, sapi_globals_id);
extern int spl_globals_id;
#else
# define SPL_G(v) (spl_globals.v)
extern zend_spl_globals spl_globals;

8
ext/standard/basic_functions.c
View File

@ -108,7 +108,7 @@ typedef struct yy_buffer_state *YY_BUFFER_STATE;
#include "php_ticks.h"
#ifdef ZTS
TSRMG_D(php_basic_globals, basic_globals_id);
PHPAPI int basic_globals_id;
#else
PHPAPI php_basic_globals basic_globals;
#endif
@ -3375,7 +3375,7 @@ zend_module_entry basic_functions_module = { /* {{{ */
PHP_RSHUTDOWN(basic), /* request shutdown */
PHP_MINFO(basic), /* extension info */
PHP_VERSION, /* extension version */
STANDARD_MODULE_PROPERTIES_EX
STANDARD_MODULE_PROPERTIES
};
/* }}} */
@ -3530,9 +3530,9 @@ PHPAPI double php_get_inf(void) /* {{{ */
PHP_MINIT_FUNCTION(basic) /* {{{ */
{
#ifdef ZTS
TSRMG_ALLOCATE(basic_globals_id, sizeof(php_basic_globals), (ts_allocate_ctor) basic_globals_ctor, (ts_allocate_dtor) basic_globals_dtor);
ts_allocate_id(&basic_globals_id, sizeof(php_basic_globals), (ts_allocate_ctor) basic_globals_ctor, (ts_allocate_dtor) basic_globals_dtor);
#ifdef PHP_WIN32
TSRMG_ALLOCATE(php_win32_core_globals_id, sizeof(php_win32_core_globals), (ts_allocate_ctor)php_win32_core_globals_ctor, (ts_allocate_dtor)php_win32_core_globals_dtor);
ts_allocate_id(&php_win32_core_globals_id, sizeof(php_win32_core_globals), (ts_allocate_ctor)php_win32_core_globals_ctor, (ts_allocate_dtor)php_win32_core_globals_dtor );
#endif
#else
basic_globals_ctor(&basic_globals TSRMLS_CC);

2
ext/standard/basic_functions.h
View File

@ -232,7 +232,7 @@ typedef struct _php_basic_globals {
#ifdef ZTS
#define BG(v) TSRMG(basic_globals_id, php_basic_globals *, v)
TSRMG_DH(php_basic_globals, basic_globals_id);
PHPAPI extern int basic_globals_id;
#else
#define BG(v) (basic_globals.v)
PHPAPI extern php_basic_globals basic_globals;

3
ext/standard/browscap.c
View File

@ -311,7 +311,8 @@ PHP_MINIT_FUNCTION(browscap) /* {{{ */
char *browscap = INI_STR("browscap");
#ifdef ZTS
TSRMG_ALLOCATE(browscap_globals_id, sizeof(browser_data), (ts_allocate_ctor) browscap_globals_ctor, NULL);
ts_allocate_id(&browscap_globals_id, sizeof(browser_data),
browscap_globals_ctor, NULL);
#endif
/* ctor call not really needed for non-ZTS */

4
ext/standard/dir.c
View File

@ -57,7 +57,7 @@ typedef struct {
#ifdef ZTS
#define DIRG(v) TSRMG(dir_globals_id, php_dir_globals *, v)
TSRMG_D(php_dir_globals, dir_globals_id);
int dir_globals_id;
#else
#define DIRG(v) (dir_globals.v)
php_dir_globals dir_globals;
@ -137,7 +137,7 @@ PHP_MINIT_FUNCTION(dir)
dir_class_entry_ptr = zend_register_internal_class(&dir_class_entry TSRMLS_CC);
#ifdef ZTS
TSRMG_ALLOCATE(dir_globals_id, sizeof(php_dir_globals), NULL, NULL);
ts_allocate_id(&dir_globals_id, sizeof(php_dir_globals), NULL, NULL);
#endif
dirsep_str[0] = DEFAULT_SLASH;

4
ext/standard/file.c
View File

@ -106,7 +106,7 @@ extern int fclose(FILE *);
#include "zend_API.h"
#ifdef ZTS
TSRMG_D(php_file_globals, file_globals_id);
int file_globals_id;
#else
php_file_globals file_globals;
#endif
@ -181,7 +181,7 @@ PHP_MINIT_FUNCTION(file)
le_stream_context = zend_register_list_destructors_ex(file_context_dtor, NULL, "stream-context", module_number);
#ifdef ZTS
TSRMG_ALLOCATE(file_globals_id, sizeof(php_file_globals), (ts_allocate_ctor) file_globals_ctor, (ts_allocate_dtor) file_globals_dtor);
ts_allocate_id(&file_globals_id, sizeof(php_file_globals), (ts_allocate_ctor) file_globals_ctor, (ts_allocate_dtor) file_globals_dtor);
#else
file_globals_ctor(&file_globals TSRMLS_CC);
#endif

2
ext/standard/file.h
View File

@ -131,7 +131,7 @@ typedef struct {
#ifdef ZTS
#define FG(v) TSRMG(file_globals_id, php_file_globals *, v)
TSRMG_DH(php_file_globals, file_globals_id);
extern PHPAPI int file_globals_id;
#else
#define FG(v) (file_globals.v)
extern PHPAPI php_file_globals file_globals;

4
ext/standard/info.c
View File

@ -778,11 +778,7 @@ PHPAPI void php_print_info(int flag TSRMLS_DC)
#endif
#ifdef ZTS
# ifdef USE___THREAD
php_info_print_table_row(2, "Thread Safety", "enabled, native TLS" );
# else
php_info_print_table_row(2, "Thread Safety", "enabled" );
# endif
#else
php_info_print_table_row(2, "Thread Safety", "disabled" );
#endif

4
ext/standard/lcg.c
View File

@ -32,7 +32,7 @@
#endif
#ifdef ZTS
TSRMG_D(php_lcg_globals, lcg_globals_id);
int lcg_globals_id;
#else
static php_lcg_globals lcg_globals;
#endif
@ -106,7 +106,7 @@ static void lcg_init_globals(php_lcg_globals *lcg_globals_p TSRMLS_DC) /* {{{ */
PHP_MINIT_FUNCTION(lcg) /* {{{ */
{
#ifdef ZTS
TSRMG_ALLOCATE(lcg_globals_id, sizeof(php_lcg_globals), (ts_allocate_ctor) lcg_init_globals, NULL);
ts_allocate_id(&lcg_globals_id, sizeof(php_lcg_globals), (ts_allocate_ctor) lcg_init_globals, NULL);
#else
lcg_init_globals(&lcg_globals);
#endif

4
main/SAPI.c
View File

@ -52,7 +52,7 @@
#include "php_content_types.h"
#ifdef ZTS
TSRMG_D(sapi_globals_struct, sapi_globals_id);
SAPI_API int sapi_globals_id;
#else
sapi_globals_struct sapi_globals;
#endif
@ -88,7 +88,7 @@ SAPI_API void sapi_startup(sapi_module_struct *sf)
sapi_module = *sf;
#ifdef ZTS
TSRMG_ALLOCATE(sapi_globals_id, sizeof(sapi_globals_struct), (ts_allocate_ctor) sapi_globals_ctor, (ts_allocate_dtor) sapi_globals_dtor);
ts_allocate_id(&sapi_globals_id, sizeof(sapi_globals_struct), (ts_allocate_ctor) sapi_globals_ctor, (ts_allocate_dtor) sapi_globals_dtor);
# ifdef PHP_WIN32
_configthreadlocale(_ENABLE_PER_THREAD_LOCALE);
# endif

2
main/SAPI.h
View File

@ -143,7 +143,7 @@ typedef struct _sapi_globals_struct {
BEGIN_EXTERN_C()
#ifdef ZTS
# define SG(v) TSRMG(sapi_globals_id, sapi_globals_struct *, v)
TSRMG_DH(sapi_globals_struct, sapi_globals_id);
SAPI_API extern int sapi_globals_id;
#else
# define SG(v) (sapi_globals.v)
extern SAPI_API sapi_globals_struct sapi_globals;

9
main/main.c
View File

@ -124,7 +124,7 @@ PHPAPI int (*php_register_internal_extensions_func)(TSRMLS_D) = php_register_int
#ifndef ZTS
php_core_globals core_globals;
#else
TSRMG_D(php_core_globals, core_globals_id);
PHPAPI int core_globals_id;
#endif
#ifdef PHP_WIN32
@ -2048,6 +2048,7 @@ int php_module_startup(sapi_module_struct *sf, zend_module_entry *additional_mod
zend_module_entry *module;
#ifdef ZTS
zend_executor_globals *executor_globals;
void ***tsrm_ls;
php_core_globals *core_globals;
#endif
@ -2072,7 +2073,7 @@ int php_module_startup(sapi_module_struct *sf, zend_module_entry *additional_mod
#endif
#ifdef ZTS
TSRMLS_INIT();
tsrm_ls = ts_resource(0);
#endif
#ifdef PHP_WIN32
@ -2111,10 +2112,10 @@ int php_module_startup(sapi_module_struct *sf, zend_module_entry *additional_mod
#ifdef ZTS
executor_globals = ts_resource(executor_globals_id);
TSRMG_ALLOCATE(core_globals_id, sizeof(php_core_globals), (ts_allocate_ctor) core_globals_ctor, (ts_allocate_dtor) core_globals_dtor);
ts_allocate_id(&core_globals_id, sizeof(php_core_globals), (ts_allocate_ctor) core_globals_ctor, (ts_allocate_dtor) core_globals_dtor);
core_globals = ts_resource(core_globals_id);
#ifdef PHP_WIN32
TSRMG_ALLOCATE(php_win32_core_globals_id, sizeof(php_win32_core_globals), (ts_allocate_ctor) php_win32_core_globals_ctor, (ts_allocate_dtor) php_win32_core_globals_dtor);
ts_allocate_id(&php_win32_core_globals_id, sizeof(php_win32_core_globals), (ts_allocate_ctor) php_win32_core_globals_ctor, (ts_allocate_dtor) php_win32_core_globals_dtor);
#endif
#else
php_startup_ticks(TSRMLS_C);

2
main/output.c
View File

@ -160,7 +160,7 @@ PHPAPI void php_output_shutdown(void)
PHPAPI int php_output_activate(TSRMLS_D)
{
#ifdef ZTS
//memset((*((void ***) tsrm_ls))[TSRM_UNSHUFFLE_RSRC_ID(output_globals_id)], 0, sizeof(zend_output_globals));
memset((*((void ***) tsrm_get_ls_cache()))[TSRM_UNSHUFFLE_RSRC_ID(output_globals_id)], 0, sizeof(zend_output_globals));
#else
memset(&output_globals, 0, sizeof(zend_output_globals));
#endif

2
main/php.h
View File

@ -301,7 +301,7 @@ static inline ZEND_ATTRIBUTE_DEPRECATED void php_std_error_handling() {}
PHPAPI void php_verror(const char *docref, const char *params, int type, const char *format, va_list args TSRMLS_DC) PHP_ATTRIBUTE_FORMAT(printf, 4, 0);
#ifdef PASS_TSRMLS
#ifdef ZTS
#define PHP_ATTR_FMT_OFFSET 1
#else
#define PHP_ATTR_FMT_OFFSET 0

2
main/php_globals.h
View File

@ -27,7 +27,7 @@ typedef struct _php_core_globals php_core_globals;
#ifdef ZTS
# define PG(v) TSRMG(core_globals_id, php_core_globals *, v)
TSRMG_DH(php_core_globals, core_globals_id);
extern PHPAPI int core_globals_id;
#else
# define PG(v) (core_globals.v)
extern ZEND_API struct _php_core_globals core_globals;

1
main/php_output.h
View File

@ -153,7 +153,6 @@ ZEND_END_MODULE_GLOBALS(output)
/* there should not be a need to use OG() from outside of output.c */
#ifdef ZTS
TSRMG_DH(php_output_globals, output_globals_id);
# define OG(v) TSRMG(output_globals_id, zend_output_globals *, v)
#else
# define OG(v) (output_globals.v)

2
sapi/apache/php_apache.c
View File

@ -129,7 +129,7 @@ static void php_apache_globals_ctor(php_apache_info_struct *apache_globals TSRML
static PHP_MINIT_FUNCTION(apache)
{
#ifdef ZTS
TSRMG_ALLOCATE(php_apache_info_id, sizeof(php_apache_info_struct), (ts_allocate_ctor) php_apache_globals_ctor, NULL);
ts_allocate_id(&php_apache_info_id, sizeof(php_apache_info_struct), (ts_allocate_ctor) php_apache_globals_ctor, NULL);
#else
php_apache_globals_ctor(&php_apache_info TSRMLS_CC);
#endif

2
sapi/apache2handler/php_apache.h
View File

@ -78,7 +78,7 @@ typedef struct {
extern zend_module_entry apache2_module_entry;
#ifdef ZTS
TSRMG_DHE(php_apache2_info_struct, php_apache2_info_id);
extern int php_apache2_info_id;
#define AP2(v) TSRMG(php_apache2_info_id, php_apache2_info_struct *, v)
#else
extern php_apache2_info_struct php_apache2_info;

4
sapi/apache2handler/php_functions.c
View File

@ -49,7 +49,7 @@
#include "php_apache.h"
#ifdef ZTS
TSRMG_DE(php_apache2_info_struct, php_apache2_info_id);
int php_apache2_info_id;
#else
php_apache2_info_struct php_apache2_info;
#endif
@ -536,7 +536,7 @@ PHP_INI_END()
static PHP_MINIT_FUNCTION(apache)
{
#ifdef ZTS
TSRMG_ALLOCATE(php_apache2_info_id, sizeof(php_apache2_info_struct), NULL, NULL);
ts_allocate_id(&php_apache2_info_id, sizeof(php_apache2_info_struct), (ts_allocate_ctor) NULL, NULL);
#endif
REGISTER_INI_ENTRIES();
return SUCCESS;

3
sapi/apache2handler/sapi_apache2.c
View File

@ -451,7 +451,6 @@ php_apache_server_startup(apr_pool_t *pconf, apr_pool_t *plog, apr_pool_t *ptemp
}
#ifdef ZTS
tsrm_startup(1, 1, 0, NULL);
TSRMLS_INIT();
#endif
sapi_startup(&apache2_sapi_module);
apache2_sapi_module.startup(&apache2_sapi_module);
@ -541,7 +540,7 @@ static int php_handler(request_rec *r)
apr_bucket *bucket;
apr_status_t rv;
request_rec * volatile parent_req = NULL;
TSRMLS_INIT();
TSRMLS_FETCH();
#define PHPAP_INI_OFF php_apache_ini_dtor(r, parent_req TSRMLS_CC);

2
sapi/apache_hooks/php_apache.c
View File

@ -1392,7 +1392,7 @@ static PHP_MINIT_FUNCTION(apache)
zend_class_entry ce;
#ifdef ZTS
TSRMG_ALLOCATE(php_apache_info_id, sizeof(php_apache_info_struct), (ts_allocate_ctor) php_apache_globals_ctor, NULL);
ts_allocate_id(&php_apache_info_id, sizeof(php_apache_info_struct), (ts_allocate_ctor) php_apache_globals_ctor, NULL);
#else
php_apache_globals_ctor(&php_apache_info TSRMLS_CC);
#endif

10
sapi/cgi/cgi_main.c
View File

@ -197,7 +197,7 @@ static void user_config_cache_entry_dtor(zval *el)
/* }}} */
#ifdef ZTS
TSRMG_D(php_cgi_globals_struct, php_cgi_globals_id);
static int php_cgi_globals_id;
#define CGIG(v) TSRMG(php_cgi_globals_id, php_cgi_globals_struct *, v)
#else
static php_cgi_globals_struct php_cgi_globals;
@ -1486,7 +1486,7 @@ static void php_cgi_globals_ctor(php_cgi_globals_struct *php_cgi_globals TSRMLS_
static PHP_MINIT_FUNCTION(cgi)
{
#ifdef ZTS
TSRMG_ALLOCATE(php_cgi_globals_id, sizeof(php_cgi_globals_struct), (ts_allocate_ctor) php_cgi_globals_ctor, NULL);
ts_allocate_id(&php_cgi_globals_id, sizeof(php_cgi_globals_struct), (ts_allocate_ctor) php_cgi_globals_ctor, NULL);
#else
php_cgi_globals_ctor(&php_cgi_globals TSRMLS_CC);
#endif
@ -1741,6 +1741,10 @@ int main(int argc, char *argv[])
int ini_entries_len = 0;
/* end of temporary locals */
#ifdef ZTS
void ***tsrm_ls;
#endif
int max_requests = 500;
int requests = 0;
int fastcgi;
@ -1785,7 +1789,7 @@ int main(int argc, char *argv[])
#ifdef ZTS
tsrm_startup(1, 1, 0, NULL);
TSRMLS_INIT();
tsrm_ls = ts_resource(0);
#endif
sapi_startup(&cgi_sapi_module);

5
sapi/cli/php_cli.c
View File

@ -1177,6 +1177,9 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine
int main(int argc, char *argv[])
#endif
{
#ifdef ZTS
void ***tsrm_ls;
#endif
#ifdef PHP_CLI_WIN32_NO_CONSOLE
int argc = __argc;
char **argv = __argv;
@ -1232,7 +1235,7 @@ int main(int argc, char *argv[])
#ifdef ZTS
tsrm_startup(1, 1, 0, NULL);
TSRMLS_INIT();
tsrm_ls = ts_resource_ex(0, NULL);
#endif
#ifdef PHP_WIN32

14
sapi/cli/php_cli_server.c
View File

@ -1188,11 +1188,8 @@ static void php_cli_server_logf(const char *format TSRMLS_DC, ...) /* {{{ */
{
char *buf = NULL;
va_list ap;
#ifdef PASS_TSRMLS
va_start(ap, tsrm_ls);
#else
va_start(ap, format);
#endif
vspprintf(&buf, 0, format, ap);
va_end(ap);
@ -2353,7 +2350,7 @@ static int php_cli_server_send_event(php_cli_server *server, php_cli_server_clie
/* }}} */
typedef struct php_cli_server_do_event_for_each_fd_callback_params {
#ifdef PASS_TSRMLS
#ifdef ZTS
void ***tsrm_ls;
#endif
php_cli_server *server;
@ -2364,6 +2361,9 @@ typedef struct php_cli_server_do_event_for_each_fd_callback_params {
static int php_cli_server_do_event_for_each_fd_callback(void *_params, php_socket_t fd, int event) /* {{{ */
{
php_cli_server_do_event_for_each_fd_callback_params *params = _params;
#ifdef ZTS
void ***tsrm_ls = params->tsrm_ls;
#endif
php_cli_server *server = params->server;
if (server->server_sock == fd) {
php_cli_server_client *client = NULL;
@ -2415,8 +2415,8 @@ static int php_cli_server_do_event_for_each_fd_callback(void *_params, php_socke
static void php_cli_server_do_event_for_each_fd(php_cli_server *server, int(*rhandler)(php_cli_server*, php_cli_server_client* TSRMLS_DC), int(*whandler)(php_cli_server*, php_cli_server_client* TSRMLS_DC) TSRMLS_DC) /* {{{ */
{
php_cli_server_do_event_for_each_fd_callback_params params = {
#ifdef PASS_TSRMLS
tsrm_ls,
#ifdef ZTS
(void ***) tsrm_get_ls_cache(),
#endif
server,
rhandler,

1
sapi/cli/php_cli_server.h
View File

@ -33,7 +33,6 @@ ZEND_END_MODULE_GLOBALS(cli_server)
#ifdef ZTS
#define CLI_SERVER_G(v) TSRMG(cli_server_globals_id, zend_cli_server_globals *, v)
TSRMG_DHE(zend_cli_server_globals, cli_server_globals_id);
#else
#define CLI_SERVER_G(v) (cli_server_globals.v)
#endif

7
sapi/embed/php_embed.c
View File

@ -155,6 +155,9 @@ static const zend_function_entry additional_functions[] = {
EMBED_SAPI_API int php_embed_init(int argc, char **argv PTSRMLS_DC)
{
zend_llist global_vars;
#ifdef ZTS
void ***tsrm_ls = NULL;
#endif
#ifdef HAVE_SIGNAL_H
#if defined(SIGPIPE) && defined(SIG_IGN)
@ -169,8 +172,8 @@ EMBED_SAPI_API int php_embed_init(int argc, char **argv PTSRMLS_DC)
#ifdef ZTS
tsrm_startup(1, 1, 0, NULL);
TSRMLS_INIT();
*ptsrm_ls = ts_resource_ex(0, NULL);
tsrm_ls = ts_resource(0);
*ptsrm_ls = tsrm_ls;
#endif
sapi_startup(&php_embed_module);

6
sapi/embed/php_embed.h
View File

@ -27,14 +27,14 @@
#include <main/php_ini.h>
#include <zend_ini.h>
#ifdef PASS_TSRMLS
#define PTSRMLS_D void ***ptsrm_ls
#ifdef ZTS
#define PTSRMLS_D void ****ptsrm_ls
#define PTSRMLS_DC , PTSRMLS_D
#define PTSRMLS_C &tsrm_ls
#define PTSRMLS_CC , PTSRMLS_C
#define PHP_EMBED_START_BLOCK(x,y) { \
void **tsrm_ls; \
void ***tsrm_ls; \
php_embed_init(x, y PTSRMLS_CC); \
zend_first_try {

3
win32/build/config.w32
View File

@ -221,8 +221,7 @@ if (PHP_DEBUG == "yes") {
}
if (PHP_ZTS == "yes") {
var tsrm_align = X64 ? 8 : 4;
ADD_FLAG("CFLAGS", "/D ZTS=1 /D USE___THREAD=1 /D TSRM_MM_ALIGNMENT=" + tsrm_align);
ADD_FLAG("CFLAGS", "/D ZTS=1");
ADD_FLAG("ZTS", "1");
} else {
ADD_FLAG("ZTS", "0");

2
win32/globals.c
View File

@ -23,7 +23,7 @@
#include "syslog.h"
#ifdef ZTS
TSRMG_D(php_win32_core_globals, php_win32_core_globals_id);
PHPAPI int php_win32_core_globals_id;
#else
php_win32_core_globals the_php_win32_core_globals;
#endif

2
win32/php_win32_globals.h
View File

@ -27,7 +27,7 @@ typedef struct _php_win32_core_globals php_win32_core_globals;
#ifdef ZTS
# define PW32G(v) TSRMG(php_win32_core_globals_id, php_win32_core_globals*, v)
TSRMG_DH(php_win32_core_globals, php_win32_core_globals_id);
extern PHPAPI int php_win32_core_globals_id;
#else
# define PW32G(v) (the_php_win32_core_globals.v)
extern PHPAPI struct _php_win32_core_globals the_php_win32_core_globals;