Remove PHAR_GLOBALS (make it respect ZEND_ENABLE_STATIC_TSRMLS_CACHE)

8 files changed, 149 insertions, 151 deletions

diff --git a/ext/phar/func_interceptors.c b/ext/phar/func_interceptors.c
index e3bdf01cf1..8cadeb5a4a 100644
--- a/ext/phar/func_interceptors.c
+++ b/ext/phar/func_interceptors.c
@@ -33,7 +33,7 @@ PHAR_FUNC(phar_opendir) /* {{{ */
 		goto skip_phar;
 	}
 
-	if ((PHAR_GLOBALS->phar_fname_map.u.flags && !zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)))
+	if ((PHAR_G(phar_fname_map.u.flags) && !zend_hash_num_elements(&(PHAR_G(phar_fname_map))))
 		&& !cached_phars.u.flags) {
 		goto skip_phar;
 	}
@@ -106,7 +106,7 @@ PHAR_FUNC(phar_file_get_contents) /* {{{ */
 		goto skip_phar;
 	}
 
-	if ((PHAR_GLOBALS->phar_fname_map.u.flags && !zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)))
+	if ((PHAR_G(phar_fname_map.u.flags) && !zend_hash_num_elements(&(PHAR_G(phar_fname_map))))
 		&& !cached_phars.u.flags) {
 		goto skip_phar;
 	}
@@ -239,7 +239,7 @@ PHAR_FUNC(phar_readfile) /* {{{ */
 		goto skip_phar;
 	}
 
-	if ((PHAR_GLOBALS->phar_fname_map.u.flags && !zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)))
+	if ((PHAR_G(phar_fname_map.u.flags) && !zend_hash_num_elements(&(PHAR_G(phar_fname_map))))
 		&& !cached_phars.u.flags) {
 		goto skip_phar;
 	}
@@ -339,7 +339,7 @@ PHAR_FUNC(phar_fopen) /* {{{ */
 		goto skip_phar;
 	}
 
-	if ((PHAR_GLOBALS->phar_fname_map.u.flags && !zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)))
+	if ((PHAR_G(phar_fname_map.u.flags) && !zend_hash_num_elements(&(PHAR_G(phar_fname_map))))
 		&& !cached_phars.u.flags) {
 		/* no need to check, include_path not even specified in fopen/ no active phars */
 		goto skip_phar;
@@ -910,7 +910,7 @@ PHAR_FUNC(phar_is_file) /* {{{ */
 		goto skip_phar;
 	}
 
-	if ((PHAR_GLOBALS->phar_fname_map.u.flags && !zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)))
+	if ((PHAR_G(phar_fname_map.u.flags) && !zend_hash_num_elements(&(PHAR_G(phar_fname_map))))
 		&& !cached_phars.u.flags) {
 		goto skip_phar;
 	}
@@ -977,7 +977,7 @@ PHAR_FUNC(phar_is_link) /* {{{ */
 		goto skip_phar;
 	}
 
-	if ((PHAR_GLOBALS->phar_fname_map.u.flags && !zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)))
+	if ((PHAR_G(phar_fname_map.u.flags) && !zend_hash_num_elements(&(PHAR_G(phar_fname_map))))
 		&& !cached_phars.u.flags) {
 		goto skip_phar;
 	}
diff --git a/ext/phar/phar.c b/ext/phar/phar.c
index 8448100f77..8c2b596c3d 100644
--- a/ext/phar/phar.c
+++ b/ext/phar/phar.c
@@ -82,8 +82,8 @@ ZEND_INI_MH(phar_ini_modify_handler) /* {{{ */
 
 	if (entry->name->len == sizeof("phar.readonly")-1) {
 		PHAR_G(readonly) = ini;
-		if (PHAR_GLOBALS->request_init && PHAR_GLOBALS->phar_fname_map.u.flags) {
-			zend_hash_apply_with_argument(&(PHAR_GLOBALS->phar_fname_map), phar_set_writeable_bit, (void *)&ini);
+		if (PHAR_G(request_init) && PHAR_G(phar_fname_map.u.flags)) {
+			zend_hash_apply_with_argument(&(PHAR_G(phar_fname_map)), phar_set_writeable_bit, (void *)&ini);
 		}
 	} else {
 		PHAR_G(require_hash) = ini;
@@ -105,16 +105,16 @@ static void phar_split_cache_list(void) /* {{{ */
 	phar_archive_data *phar;
 	uint i = 0;
 
-	if (!PHAR_GLOBALS->cache_list || !(PHAR_GLOBALS->cache_list[0])) {
+	if (!PHAR_G(cache_list) || !(PHAR_G(cache_list)[0])) {
 		return;
 	}
 
 	ds[0] = DEFAULT_DIR_SEPARATOR;
 	ds[1] = '\0';
-	tmp = estrdup(PHAR_GLOBALS->cache_list);
+	tmp = estrdup(PHAR_G(cache_list));
 
 	/* fake request startup */
-	PHAR_GLOBALS->request_init = 1;
+	PHAR_G(request_init) = 1;
 	zend_hash_init(&EG(regular_list), 0, NULL, NULL, 0);
 	EG(regular_list).nNextFreeElement=1;	/* we don't want resource id 0 */
 
@@ -124,10 +124,10 @@ static void phar_split_cache_list(void) /* {{{ */
 	zend_hash_init(&cached_phars, sizeof(phar_archive_data*), zend_get_hash_value, destroy_phar_data,  1);
 	zend_hash_init(&cached_alias, sizeof(phar_archive_data*), zend_get_hash_value, NULL, 1);
 	/* these two are real and will be copied over cached_phars/cached_alias later */
-	zend_hash_init(&(PHAR_GLOBALS->phar_fname_map), sizeof(phar_archive_data*), zend_get_hash_value, destroy_phar_data,  1);
-	zend_hash_init(&(PHAR_GLOBALS->phar_alias_map), sizeof(phar_archive_data*), zend_get_hash_value, NULL, 1);
-	PHAR_GLOBALS->manifest_cached = 1;
-	PHAR_GLOBALS->persist = 1;
+	zend_hash_init(&(PHAR_G(phar_fname_map)), sizeof(phar_archive_data*), zend_get_hash_value, destroy_phar_data,  1);
+	zend_hash_init(&(PHAR_G(phar_alias_map)), sizeof(phar_archive_data*), zend_get_hash_value, NULL, 1);
+	PHAR_G(manifest_cached) = 1;
+	PHAR_G(persist) = 1;
 
 	for (key = php_strtok_r(tmp, ds, &lasts);
 			key;
@@ -142,19 +142,19 @@ finish_up:
 				phar->fp = NULL;
 			} else {
 finish_error:
-				PHAR_GLOBALS->persist = 0;
-				PHAR_GLOBALS->manifest_cached = 0;
+				PHAR_G(persist) = 0;
+				PHAR_G(manifest_cached) = 0;
 				efree(tmp);
 				zend_hash_destroy(&(PHAR_G(phar_fname_map)));
-				PHAR_GLOBALS->phar_fname_map.u.flags = 0;
+				PHAR_G(phar_fname_map.u.flags) = 0;
 				zend_hash_destroy(&(PHAR_G(phar_alias_map)));
-				PHAR_GLOBALS->phar_alias_map.u.flags = 0;
+				PHAR_G(phar_alias_map.u.flags) = 0;
 				zend_hash_destroy(&cached_phars);
 				zend_hash_destroy(&cached_alias);
 				zend_hash_graceful_reverse_destroy(&EG(regular_list));
 				memset(&EG(regular_list), 0, sizeof(HashTable));
 				/* free cached manifests */
-				PHAR_GLOBALS->request_init = 0;
+				PHAR_G(request_init) = 0;
 				return;
 			}
 		} else {
@@ -166,15 +166,15 @@ finish_error:
 		}
 	}
 
-	PHAR_GLOBALS->persist = 0;
-	PHAR_GLOBALS->request_init = 0;
+	PHAR_G(persist) = 0;
+	PHAR_G(request_init) = 0;
 	/* destroy dummy values from before */
 	zend_hash_destroy(&cached_phars);
 	zend_hash_destroy(&cached_alias);
-	cached_phars = PHAR_GLOBALS->phar_fname_map;
-	cached_alias = PHAR_GLOBALS->phar_alias_map;
-	PHAR_GLOBALS->phar_fname_map.u.flags = 0;
-	PHAR_GLOBALS->phar_alias_map.u.flags = 0;
+	cached_phars = PHAR_G(phar_fname_map);
+	cached_alias = PHAR_G(phar_alias_map);
+	PHAR_G(phar_fname_map.u.flags) = 0;
+	PHAR_G(phar_alias_map.u.flags) = 0;
 	zend_hash_graceful_reverse_destroy(&EG(regular_list));
 	memset(&EG(regular_list), 0, sizeof(HashTable));
 	efree(tmp);
@@ -274,8 +274,8 @@ int phar_archive_delref(phar_archive_data *phar) /* {{{ */
 	}
 
 	if (--phar->refcount < 0) {
-		if (PHAR_GLOBALS->request_done
-		|| zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), phar->fname, phar->fname_len) != SUCCESS) {
+		if (PHAR_G(request_done)
+		|| zend_hash_str_del(&(PHAR_G(phar_fname_map)), phar->fname, phar->fname_len) != SUCCESS) {
 			phar_destroy_phar_data(phar);
 		}
 		return 1;
@@ -296,7 +296,7 @@ int phar_archive_delref(phar_archive_data *phar) /* {{{ */
 		if (!zend_hash_num_elements(&phar->manifest)) {
 			/* this is a new phar that has perhaps had an alias/metadata set, but has never
 			been flushed */
-			if (zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), phar->fname, phar->fname_len) != SUCCESS) {
+			if (zend_hash_str_del(&(PHAR_G(phar_fname_map)), phar->fname, phar->fname_len) != SUCCESS) {
 				phar_destroy_phar_data(phar);
 			}
 			return 1;
@@ -355,7 +355,7 @@ static void destroy_phar_data(zval *zv) /* {{{ */
 {
 	phar_archive_data *phar_data = (phar_archive_data *)Z_PTR_P(zv);
 
-	if (PHAR_GLOBALS->request_ends) {
+	if (PHAR_G(request_ends)) {
 		/* first, iterate over the manifest and close all PHAR_TMP entry fp handles,
 		this prevents unnecessary unfreed stream resources */
 		zend_hash_apply(&(phar_data->manifest), phar_tmpclose_apply);
@@ -363,7 +363,7 @@ static void destroy_phar_data(zval *zv) /* {{{ */
 		return;
 	}
 
-	zend_hash_apply_with_argument(&(PHAR_GLOBALS->phar_alias_map), phar_unalias_apply, phar_data);
+	zend_hash_apply_with_argument(&(PHAR_G(phar_alias_map)), phar_unalias_apply, phar_data);
 
 	if (--phar_data->refcount < 0) {
 		phar_destroy_phar_data(phar_data);
@@ -1214,7 +1214,7 @@ static int phar_parse_pharfile(php_stream *fp, char *fname, int fname_len, char
 			MAPPHAR_FAIL("Cannot open archive \"%s\", invalid alias");
 		}
 
-		if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len))) {
+		if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_alias_map)), alias, alias_len))) {
 			if (SUCCESS != phar_free_alias(fd_ptr, alias, alias_len)) {
 				signature = NULL;
 				fp = NULL;
@@ -1222,12 +1222,12 @@ static int phar_parse_pharfile(php_stream *fp, char *fname, int fname_len, char
 			}
 		}
 
-		zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, mydata);
+		zend_hash_str_add_ptr(&(PHAR_G(phar_alias_map)), alias, alias_len, mydata);
 	} else {
 		mydata->is_temporary_alias = 1;
 	}
 
-	zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len, mydata);
+	zend_hash_str_add_ptr(&(PHAR_G(phar_fname_map)), mydata->fname, fname_len, mydata);
 	efree(savebuf);
 
 	if (pphar) {
@@ -1413,7 +1413,7 @@ int phar_create_or_parse_filename(char *fname, int fname_len, char *alias, int a
 	mydata->is_writeable = 1;
 	mydata->is_brandnew = 1;
 	phar_request_initialize();
-	zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len, mydata);
+	zend_hash_str_add_ptr(&(PHAR_G(phar_fname_map)), mydata->fname, fname_len, mydata);
 
 	if (is_data) {
 		alias = NULL;
@@ -1424,13 +1424,13 @@ int phar_create_or_parse_filename(char *fname, int fname_len, char *alias, int a
 	} else {
 		phar_archive_data *fd_ptr;
 
-		if (alias && NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len))) {
+		if (alias && NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_alias_map)), alias, alias_len))) {
 			if (SUCCESS != phar_free_alias(fd_ptr, alias, alias_len)) {
 				if (error) {
 					spprintf(error, 4096, "phar error: phar \"%s\" cannot set alias \"%s\", already in use by another phar archive", mydata->fname, alias);
 				}
 
-				zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len);
+				zend_hash_str_del(&(PHAR_G(phar_fname_map)), mydata->fname, fname_len);
 
 				if (pphar) {
 					*pphar = NULL;
@@ -1445,14 +1445,14 @@ int phar_create_or_parse_filename(char *fname, int fname_len, char *alias, int a
 	}
 
 	if (alias_len && alias) {
-		if (NULL == zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, mydata)) {
+		if (NULL == zend_hash_str_add_ptr(&(PHAR_G(phar_alias_map)), alias, alias_len, mydata)) {
 			if (options & REPORT_ERRORS) {
 				if (error) {
 					spprintf(error, 0, "archive \"%s\" cannot be associated with alias \"%s\", already in use", fname, alias);
 				}
 			}
 
-			zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len);
+			zend_hash_str_del(&(PHAR_G(phar_fname_map)), mydata->fname, fname_len);
 
 			if (pphar) {
 				*pphar = NULL;
@@ -1746,7 +1746,7 @@ static int phar_analyze_path(const char *fname, const char *ext, int ext_len, in
 #ifdef PHP_WIN32
 		phar_unixify_path_separators(realpath, strlen(realpath));
 #endif
-		if (zend_hash_str_exists(&(PHAR_GLOBALS->phar_fname_map), realpath, strlen(realpath))) {
+		if (zend_hash_str_exists(&(PHAR_G(phar_fname_map)), realpath, strlen(realpath))) {
 			efree(realpath);
 			efree(filename);
 			return SUCCESS;
@@ -1915,7 +1915,7 @@ int phar_detect_phar_fname_ext(const char *filename, int filename_len, const cha
 			*ext_str = NULL;
 			return FAILURE;
 		}
-		if (zend_hash_str_exists(&(PHAR_GLOBALS->phar_alias_map), (char *) filename, pos - filename)) {
+		if (zend_hash_str_exists(&(PHAR_G(phar_alias_map)), (char *) filename, pos - filename)) {
 			*ext_str = pos;
 			*ext_len = -1;
 			return FAILURE;
@@ -1928,11 +1928,11 @@ int phar_detect_phar_fname_ext(const char *filename, int filename_len, const cha
 		}
 	}
 
-	if (zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)) || PHAR_G(manifest_cached)) {
+	if (zend_hash_num_elements(&(PHAR_G(phar_fname_map))) || PHAR_G(manifest_cached)) {
 		phar_archive_data *pphar;
 
 		if (is_complete) {
-			if (NULL != (pphar = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_fname_map), (char *) filename, filename_len))) {
+			if (NULL != (pphar = zend_hash_str_find_ptr(&(PHAR_G(phar_fname_map)), (char *) filename, filename_len))) {
 				*ext_str = filename + (filename_len - pphar->ext_len);
 woohoo:
 				*ext_len = pphar->ext_len;
@@ -1960,9 +1960,9 @@ woohoo:
 			zend_string *str_key;
 			zend_ulong unused;
 
-			for (zend_hash_internal_pointer_reset(&(PHAR_GLOBALS->phar_fname_map));
-				HASH_KEY_NON_EXISTENT != zend_hash_get_current_key(&(PHAR_GLOBALS->phar_fname_map), &str_key, &unused);
-				zend_hash_move_forward(&(PHAR_GLOBALS->phar_fname_map))
+			for (zend_hash_internal_pointer_reset(&(PHAR_G(phar_fname_map)));
+				HASH_KEY_NON_EXISTENT != zend_hash_get_current_key(&(PHAR_G(phar_fname_map)), &str_key, &unused);
+				zend_hash_move_forward(&(PHAR_G(phar_fname_map)))
 			) {
 				if (str_key->len > (uint) filename_len) {
 					continue;
@@ -1970,7 +1970,7 @@ woohoo:
 
 				if (!memcmp(filename, str_key->val, str_key->len) && ((uint)filename_len == str_key->len
 					|| filename[str_key->len] == '/' || filename[str_key->len] == '\0')) {
-					if (NULL == (pphar = zend_hash_get_current_data_ptr(&(PHAR_GLOBALS->phar_fname_map)))) {
+					if (NULL == (pphar = zend_hash_get_current_data_ptr(&(PHAR_G(phar_fname_map))))) {
 						break;
 					}
 					*ext_str = filename + (str_key->len - pphar->ext_len);
@@ -3299,7 +3299,7 @@ static zend_op_array *phar_compile_file(zend_file_handle *file_handle, int type)
 				file_handle->handle.stream.fsizer  = phar_zend_stream_fsizer;
 				file_handle->handle.stream.isatty  = 0;
 				phar->is_persistent ?
-					php_stream_rewind(PHAR_GLOBALS->cached_fp[phar->phar_pos].fp) :
+					php_stream_rewind(PHAR_G(cached_fp)[phar->phar_pos].fp) :
 					php_stream_rewind(phar->fp);
 				memset(&file_handle->handle.stream.mmap, 0, sizeof(file_handle->handle.stream.mmap));
 			}
@@ -3444,18 +3444,18 @@ PHP_MSHUTDOWN_FUNCTION(phar) /* {{{ */
 
 void phar_request_initialize(void) /* {{{ */
 {
-	if (!PHAR_GLOBALS->request_init)
+	if (!PHAR_G(request_init))
 	{
 		PHAR_G(last_phar) = NULL;
 		PHAR_G(last_phar_name) = PHAR_G(last_alias) = NULL;
 		PHAR_G(has_bz2) = zend_hash_str_exists(&module_registry, "bz2", sizeof("bz2")-1);
 		PHAR_G(has_zlib) = zend_hash_str_exists(&module_registry, "zlib", sizeof("zlib")-1);
-		PHAR_GLOBALS->request_init = 1;
-		PHAR_GLOBALS->request_ends = 0;
-		PHAR_GLOBALS->request_done = 0;
-		zend_hash_init(&(PHAR_GLOBALS->phar_fname_map), 5, zend_get_hash_value, destroy_phar_data,  0);
-		zend_hash_init(&(PHAR_GLOBALS->phar_persist_map), 5, zend_get_hash_value, NULL,  0);
-		zend_hash_init(&(PHAR_GLOBALS->phar_alias_map), 5, zend_get_hash_value, NULL, 0);
+		PHAR_G(request_init) = 1;
+		PHAR_G(request_ends) = 0;
+		PHAR_G(request_done) = 0;
+		zend_hash_init(&(PHAR_G(phar_fname_map)), 5, zend_get_hash_value, destroy_phar_data,  0);
+		zend_hash_init(&(PHAR_G(phar_persist_map)), 5, zend_get_hash_value, NULL,  0);
+		zend_hash_init(&(PHAR_G(phar_alias_map)), 5, zend_get_hash_value, NULL, 0);
 
 		if (PHAR_G(manifest_cached)) {
 			phar_archive_data *pphar;
@@ -3467,10 +3467,10 @@ void phar_request_initialize(void) /* {{{ */
 				stuff[pphar->phar_pos].manifest = (phar_entry_fp_info *) ecalloc( zend_hash_num_elements(&(pphar->manifest)), sizeof(phar_entry_fp_info));
 			}
 
-			PHAR_GLOBALS->cached_fp = stuff;
+			PHAR_G(cached_fp) = stuff;
 		}
 
-		PHAR_GLOBALS->phar_SERVER_mung_list = 0;
+		PHAR_G(phar_SERVER_mung_list) = 0;
 		PHAR_G(cwd) = NULL;
 		PHAR_G(cwd_len) = 0;
 		PHAR_G(cwd_init) = 0;
@@ -3482,34 +3482,34 @@ PHP_RSHUTDOWN_FUNCTION(phar) /* {{{ */
 {
 	int i;
 
-	PHAR_GLOBALS->request_ends = 1;
+	PHAR_G(request_ends) = 1;
 
-	if (PHAR_GLOBALS->request_init)
+	if (PHAR_G(request_init))
 	{
 		phar_release_functions();
-		zend_hash_destroy(&(PHAR_GLOBALS->phar_alias_map));
-		PHAR_GLOBALS->phar_alias_map.u.flags = 0;
-		zend_hash_destroy(&(PHAR_GLOBALS->phar_fname_map));
-		PHAR_GLOBALS->phar_fname_map.u.flags = 0;
-		zend_hash_destroy(&(PHAR_GLOBALS->phar_persist_map));
-		PHAR_GLOBALS->phar_persist_map.u.flags = 0;
-		PHAR_GLOBALS->phar_SERVER_mung_list = 0;
-
-		if (PHAR_GLOBALS->cached_fp) {
+		zend_hash_destroy(&(PHAR_G(phar_alias_map)));
+		PHAR_G(phar_alias_map.u.flags) = 0;
+		zend_hash_destroy(&(PHAR_G(phar_fname_map)));
+		PHAR_G(phar_fname_map.u.flags) = 0;
+		zend_hash_destroy(&(PHAR_G(phar_persist_map)));
+		PHAR_G(phar_persist_map.u.flags) = 0;
+		PHAR_G(phar_SERVER_mung_list) = 0;
+
+		if (PHAR_G(cached_fp)) {
 			for (i = 0; i < zend_hash_num_elements(&cached_phars); ++i) {
-				if (PHAR_GLOBALS->cached_fp[i].fp) {
-					php_stream_close(PHAR_GLOBALS->cached_fp[i].fp);
+				if (PHAR_G(cached_fp)[i].fp) {
+					php_stream_close(PHAR_G(cached_fp)[i].fp);
 				}
-				if (PHAR_GLOBALS->cached_fp[i].ufp) {
-					php_stream_close(PHAR_GLOBALS->cached_fp[i].ufp);
+				if (PHAR_G(cached_fp)[i].ufp) {
+					php_stream_close(PHAR_G(cached_fp)[i].ufp);
 				}
-				efree(PHAR_GLOBALS->cached_fp[i].manifest);
+				efree(PHAR_G(cached_fp)[i].manifest);
 			}
-			efree(PHAR_GLOBALS->cached_fp);
-			PHAR_GLOBALS->cached_fp = 0;
+			efree(PHAR_G(cached_fp));
+			PHAR_G(cached_fp) = 0;
 		}
 
-		PHAR_GLOBALS->request_init = 0;
+		PHAR_G(request_init) = 0;
 
 		if (PHAR_G(cwd)) {
 			efree(PHAR_G(cwd));
@@ -3520,7 +3520,7 @@ PHP_RSHUTDOWN_FUNCTION(phar) /* {{{ */
 		PHAR_G(cwd_init) = 0;
 	}
 
-	PHAR_GLOBALS->request_done = 1;
+	PHAR_G(request_done) = 1;
 	return SUCCESS;
 }
 /* }}} */
diff --git a/ext/phar/phar_internal.h b/ext/phar/phar_internal.h
index ccff36770b..63e00bd260 100644
--- a/ext/phar/phar_internal.h
+++ b/ext/phar/phar_internal.h
@@ -200,10 +200,8 @@ ZEND_EXTERN_MODULE_GLOBALS(phar)
 ZEND_TSRMLS_CACHE_EXTERN();
 #   endif
 #	define PHAR_G(v) ZEND_TSRMG(phar_globals_id, zend_phar_globals *, v)
-#	define PHAR_GLOBALS ((zend_phar_globals *) (*((void ***) ZEND_TSRMLS_CACHE))[TSRM_UNSHUFFLE_RSRC_ID(phar_globals_id)])
 #else
 #	define PHAR_G(v) (phar_globals.v)
-#	define PHAR_GLOBALS (&phar_globals)
 #endif
 
 #ifndef php_uint16
@@ -351,7 +349,7 @@ static inline php_stream *phar_get_entrypfp(phar_entry_info *entry)
 	if (!entry->is_persistent) {
 		return entry->phar->fp;
 	}
-	return PHAR_GLOBALS->cached_fp[entry->phar->phar_pos].fp;
+	return PHAR_G(cached_fp)[entry->phar->phar_pos].fp;
 }
 
 static inline php_stream *phar_get_entrypufp(phar_entry_info *entry)
@@ -359,7 +357,7 @@ static inline php_stream *phar_get_entrypufp(phar_entry_info *entry)
 	if (!entry->is_persistent) {
 		return entry->phar->ufp;
 	}
-	return PHAR_GLOBALS->cached_fp[entry->phar->phar_pos].ufp;
+	return PHAR_G(cached_fp)[entry->phar->phar_pos].ufp;
 }
 
 static inline void phar_set_entrypfp(phar_entry_info *entry, php_stream *fp)
@@ -369,7 +367,7 @@ static inline void phar_set_entrypfp(phar_entry_info *entry, php_stream *fp)
 		return;
 	}
 
-	PHAR_GLOBALS->cached_fp[entry->phar->phar_pos].fp = fp;
+	PHAR_G(cached_fp)[entry->phar->phar_pos].fp = fp;
 }
 
 static inline void phar_set_entrypufp(phar_entry_info *entry, php_stream *fp)
@@ -379,7 +377,7 @@ static inline void phar_set_entrypufp(phar_entry_info *entry, php_stream *fp)
 		return;
 	}
 
-	PHAR_GLOBALS->cached_fp[entry->phar->phar_pos].ufp = fp;
+	PHAR_G(cached_fp)[entry->phar->phar_pos].ufp = fp;
 }
 
 static inline php_stream *phar_get_pharfp(phar_archive_data *phar)
@@ -387,7 +385,7 @@ static inline php_stream *phar_get_pharfp(phar_archive_data *phar)
 	if (!phar->is_persistent) {
 		return phar->fp;
 	}
-	return PHAR_GLOBALS->cached_fp[phar->phar_pos].fp;
+	return PHAR_G(cached_fp)[phar->phar_pos].fp;
 }
 
 static inline php_stream *phar_get_pharufp(phar_archive_data *phar)
@@ -395,7 +393,7 @@ static inline php_stream *phar_get_pharufp(phar_archive_data *phar)
 	if (!phar->is_persistent) {
 		return phar->ufp;
 	}
-	return PHAR_GLOBALS->cached_fp[phar->phar_pos].ufp;
+	return PHAR_G(cached_fp)[phar->phar_pos].ufp;
 }
 
 static inline void phar_set_pharfp(phar_archive_data *phar, php_stream *fp)
@@ -405,7 +403,7 @@ static inline void phar_set_pharfp(phar_archive_data *phar, php_stream *fp)
 		return;
 	}
 
-	PHAR_GLOBALS->cached_fp[phar->phar_pos].fp = fp;
+	PHAR_G(cached_fp)[phar->phar_pos].fp = fp;
 }
 
 static inline void phar_set_pharufp(phar_archive_data *phar, php_stream *fp)
@@ -415,7 +413,7 @@ static inline void phar_set_pharufp(phar_archive_data *phar, php_stream *fp)
 		return;
 	}
 
-	PHAR_GLOBALS->cached_fp[phar->phar_pos].ufp = fp;
+	PHAR_G(cached_fp)[phar->phar_pos].ufp = fp;
 }
 
 static inline void phar_set_fp_type(phar_entry_info *entry, enum phar_fp_type type, zend_off_t offset)
@@ -427,7 +425,7 @@ static inline void phar_set_fp_type(phar_entry_info *entry, enum phar_fp_type ty
 		entry->offset = offset;
 		return;
 	}
-	data = &(PHAR_GLOBALS->cached_fp[entry->phar->phar_pos].manifest[entry->manifest_pos]);
+	data = &(PHAR_G(cached_fp)[entry->phar->phar_pos].manifest[entry->manifest_pos]);
 	data->fp_type = type;
 	data->offset = offset;
 }
@@ -437,7 +435,7 @@ static inline enum phar_fp_type phar_get_fp_type(phar_entry_info *entry)
 	if (!entry->is_persistent) {
 		return entry->fp_type;
 	}
-	return PHAR_GLOBALS->cached_fp[entry->phar->phar_pos].manifest[entry->manifest_pos].fp_type;
+	return PHAR_G(cached_fp)[entry->phar->phar_pos].manifest[entry->manifest_pos].fp_type;
 }
 
 static inline zend_off_t phar_get_fp_offset(phar_entry_info *entry)
@@ -445,12 +443,12 @@ static inline zend_off_t phar_get_fp_offset(phar_entry_info *entry)
 	if (!entry->is_persistent) {
 		return entry->offset;
 	}
-	if (PHAR_GLOBALS->cached_fp[entry->phar->phar_pos].manifest[entry->manifest_pos].fp_type == PHAR_FP) {
-		if (!PHAR_GLOBALS->cached_fp[entry->phar->phar_pos].manifest[entry->manifest_pos].offset) {
-			PHAR_GLOBALS->cached_fp[entry->phar->phar_pos].manifest[entry->manifest_pos].offset = entry->offset;
+	if (PHAR_G(cached_fp)[entry->phar->phar_pos].manifest[entry->manifest_pos].fp_type == PHAR_FP) {
+		if (!PHAR_G(cached_fp)[entry->phar->phar_pos].manifest[entry->manifest_pos].offset) {
+			PHAR_G(cached_fp)[entry->phar->phar_pos].manifest[entry->manifest_pos].offset = entry->offset;
 		}
 	}
-	return PHAR_GLOBALS->cached_fp[entry->phar->phar_pos].manifest[entry->manifest_pos].offset;
+	return PHAR_G(cached_fp)[entry->phar->phar_pos].manifest[entry->manifest_pos].offset;
 }
 
 #define PHAR_MIME_PHP '\0'
diff --git a/ext/phar/phar_object.c b/ext/phar/phar_object.c
index d5f84b87de..69bda4bab3 100644
--- a/ext/phar/phar_object.c
+++ b/ext/phar/phar_object.c
@@ -92,11 +92,11 @@ static void phar_mung_server_vars(char *fname, char *entry, int entry_len, char
 		zend_hash_str_update(_SERVER, "PHAR_PATH_TRANSLATED", sizeof("PHAR_PATH_TRANSLATED")-1, &temp);
 	}
 
-	if (!PHAR_GLOBALS->phar_SERVER_mung_list) {
+	if (!PHAR_G(phar_SERVER_mung_list)) {
 		return;
 	}
 
-	if (PHAR_GLOBALS->phar_SERVER_mung_list & PHAR_MUNG_REQUEST_URI) {
+	if (PHAR_G(phar_SERVER_mung_list) & PHAR_MUNG_REQUEST_URI) {
 		if (NULL != (stuff = zend_hash_str_find(_SERVER, "REQUEST_URI", sizeof("REQUEST_URI")-1))) {
 			path_info = Z_STRVAL_P(stuff);
 			code = Z_STRLEN_P(stuff);
@@ -108,7 +108,7 @@ static void phar_mung_server_vars(char *fname, char *entry, int entry_len, char
 		}
 	}
 
-	if (PHAR_GLOBALS->phar_SERVER_mung_list & PHAR_MUNG_PHP_SELF) {
+	if (PHAR_G(phar_SERVER_mung_list) & PHAR_MUNG_PHP_SELF) {
 		if (NULL != (stuff = zend_hash_str_find(_SERVER, "PHP_SELF", sizeof("PHP_SELF")-1))) {
 			path_info = Z_STRVAL_P(stuff);
 			code = Z_STRLEN_P(stuff);
@@ -121,7 +121,7 @@ static void phar_mung_server_vars(char *fname, char *entry, int entry_len, char
 		}
 	}
 
-	if (PHAR_GLOBALS->phar_SERVER_mung_list & PHAR_MUNG_SCRIPT_NAME) {
+	if (PHAR_G(phar_SERVER_mung_list) & PHAR_MUNG_SCRIPT_NAME) {
 		if (NULL != (stuff = zend_hash_str_find(_SERVER, "SCRIPT_NAME", sizeof("SCRIPT_NAME")-1))) {
 			ZVAL_STR(&temp, Z_STR_P(stuff));
 			ZVAL_STRINGL(stuff, entry, entry_len);
@@ -129,7 +129,7 @@ static void phar_mung_server_vars(char *fname, char *entry, int entry_len, char
 		}
 	}
 
-	if (PHAR_GLOBALS->phar_SERVER_mung_list & PHAR_MUNG_SCRIPT_FILENAME) {
+	if (PHAR_G(phar_SERVER_mung_list) & PHAR_MUNG_SCRIPT_FILENAME) {
 		if (NULL != (stuff = zend_hash_str_find(_SERVER, "SCRIPT_FILENAME", sizeof("SCRIPT_FILENAME")-1))) {
 			zend_string *str = strpprintf(4096, "phar://%s%s", fname, entry);
 
@@ -357,7 +357,7 @@ static void phar_postprocess_ru_web(char *fname, int fname_len, char **entry, in
 	phar_archive_data *pphar;
 
 	/* we already know we can retrieve the phar if we reach here */
-	pphar = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_fname_map), fname, fname_len);
+	pphar = zend_hash_str_find_ptr(&(PHAR_G(phar_fname_map)), fname, fname_len);
 
 	if (!pphar && PHAR_G(manifest_cached)) {
 		pphar = zend_hash_str_find_ptr(&cached_phars, fname, fname_len);
@@ -480,7 +480,7 @@ PHP_METHOD(Phar, mount)
 			return;
 		}
 carry_on2:
-		if (NULL == (pphar = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_fname_map), arch, arch_len))) {
+		if (NULL == (pphar = zend_hash_str_find_ptr(&(PHAR_G(phar_fname_map)), arch, arch_len))) {
 			if (PHAR_G(manifest_cached) && NULL != (pphar = zend_hash_str_find_ptr(&cached_phars, arch, arch_len))) {
 				if (SUCCESS == phar_copy_on_write(&pphar)) {
 					goto carry_on;
@@ -517,7 +517,7 @@ carry_on:
 		}
 
 		return;
-	} else if (PHAR_GLOBALS->phar_fname_map.u.flags && NULL != (pphar = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_fname_map), fname, fname_len))) {
+	} else if (PHAR_G(phar_fname_map.u.flags) && NULL != (pphar = zend_hash_str_find_ptr(&(PHAR_G(phar_fname_map)), fname, fname_len))) {
 		goto carry_on;
 	} else if (PHAR_G(manifest_cached) && NULL != (pphar = zend_hash_str_find_ptr(&cached_phars, fname, fname_len))) {
 		if (SUCCESS == phar_copy_on_write(&pphar)) {
@@ -881,20 +881,20 @@ PHP_METHOD(Phar, mungServer)
 		}
 
 		if (Z_STRLEN_P(data) == sizeof("PHP_SELF")-1 && !strncmp(Z_STRVAL_P(data), "PHP_SELF", sizeof("PHP_SELF")-1)) {
-			PHAR_GLOBALS->phar_SERVER_mung_list |= PHAR_MUNG_PHP_SELF;
+			PHAR_G(phar_SERVER_mung_list) |= PHAR_MUNG_PHP_SELF;
 		}
 
 		if (Z_STRLEN_P(data) == sizeof("REQUEST_URI")-1) {
 			if (!strncmp(Z_STRVAL_P(data), "REQUEST_URI", sizeof("REQUEST_URI")-1)) {
-				PHAR_GLOBALS->phar_SERVER_mung_list |= PHAR_MUNG_REQUEST_URI;
+				PHAR_G(phar_SERVER_mung_list) |= PHAR_MUNG_REQUEST_URI;
 			}
 			if (!strncmp(Z_STRVAL_P(data), "SCRIPT_NAME", sizeof("SCRIPT_NAME")-1)) {
-				PHAR_GLOBALS->phar_SERVER_mung_list |= PHAR_MUNG_SCRIPT_NAME;
+				PHAR_G(phar_SERVER_mung_list) |= PHAR_MUNG_SCRIPT_NAME;
 			}
 		}
 
 		if (Z_STRLEN_P(data) == sizeof("SCRIPT_FILENAME")-1 && !strncmp(Z_STRVAL_P(data), "SCRIPT_FILENAME", sizeof("SCRIPT_FILENAME")-1)) {
-			PHAR_GLOBALS->phar_SERVER_mung_list |= PHAR_MUNG_SCRIPT_FILENAME;
+			PHAR_G(phar_SERVER_mung_list) |= PHAR_MUNG_SCRIPT_FILENAME;
 		}
 	} ZEND_HASH_FOREACH_END();
 }
@@ -1231,7 +1231,7 @@ PHP_METHOD(Phar, __construct)
 		phar_obj->archive->is_data = is_data;
 	} else if (!EG(exception)) {
 		/* register this guy so we can modify if necessary */
-		zend_hash_str_add_ptr(&PHAR_GLOBALS->phar_persist_map, (const char *) phar_obj->archive, sizeof(phar_obj->archive), phar_obj);
+		zend_hash_str_add_ptr(&PHAR_G(phar_persist_map), (const char *) phar_obj->archive, sizeof(phar_obj->archive), phar_obj);
 	}
 
 	phar_obj->spl.info_class = phar_ce_entry;
@@ -1375,7 +1375,7 @@ PHP_METHOD(Phar, __destruct)
 	phar_archive_object *phar_obj = (phar_archive_object*)((char*)Z_OBJ_P(zobj) - Z_OBJ_P(zobj)->handlers->offset);
 
 	if (phar_obj->archive && phar_obj->archive->is_persistent) {
-		zend_hash_str_del(&PHAR_GLOBALS->phar_persist_map, (const char *) phar_obj->archive, sizeof(phar_obj->archive));
+		zend_hash_str_del(&PHAR_G(phar_persist_map), (const char *) phar_obj->archive, sizeof(phar_obj->archive));
 	}
 }
 /* }}} */
@@ -2090,7 +2090,7 @@ static zend_object *phar_rename_archive(phar_archive_data *phar, char *ext, zend
 		return NULL;
 	}
 
-	if (NULL != (pphar = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_fname_map), newpath, phar->fname_len))) {
+	if (NULL != (pphar = zend_hash_str_find_ptr(&(PHAR_G(phar_fname_map)), newpath, phar->fname_len))) {
 		if (pphar->fname_len == phar->fname_len && !memcmp(pphar->fname, phar->fname, phar->fname_len)) {
 			if (!zend_hash_num_elements(&phar->manifest)) {
 				pphar->is_tar = phar->is_tar;
@@ -2132,7 +2132,7 @@ its_ok:
 				phar->alias = estrndup(newpath, strlen(newpath));
 				phar->alias_len = strlen(newpath);
 				phar->is_temporary_alias = 1;
-				zend_hash_str_update_ptr(&(PHAR_GLOBALS->phar_alias_map), newpath, phar->fname_len, phar);
+				zend_hash_str_update_ptr(&(PHAR_G(phar_alias_map)), newpath, phar->fname_len, phar);
 			}
 		}
 
@@ -2148,7 +2148,7 @@ its_ok:
 		phar->alias_len = 0;
 	}
 
-	if ((!pphar || phar == pphar) && NULL == zend_hash_str_update_ptr(&(PHAR_GLOBALS->phar_fname_map), newpath, phar->fname_len, phar)) {
+	if ((!pphar || phar == pphar) && NULL == zend_hash_str_update_ptr(&(PHAR_G(phar_fname_map)), newpath, phar->fname_len, phar)) {
 		efree(oldpath);
 		zend_throw_exception_ex(spl_ce_BadMethodCallException, 0, "Unable to add newly converted phar \"%s\" to the list of phars", phar->fname);
 		return NULL;
@@ -2676,7 +2676,7 @@ PHP_METHOD(Phar, setAlias)
 		if (alias_len == phar_obj->archive->alias_len && memcmp(phar_obj->archive->alias, alias, alias_len) == 0) {
 			RETURN_TRUE;
 		}
-		if (alias_len && NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len))) {
+		if (alias_len && NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_alias_map)), alias, alias_len))) {
 			spprintf(&error, 0, "alias \"%s\" is already used for archive \"%s\" and cannot be used for other archives", alias, fd_ptr->fname);
 			if (SUCCESS == phar_free_alias(fd_ptr, alias, alias_len)) {
 				efree(error);
@@ -2696,8 +2696,8 @@ valid_alias:
 			zend_throw_exception_ex(phar_ce_PharException, 0, "phar \"%s\" is persistent, unable to copy on write", phar_obj->archive->fname);
 			return;
 		}
-		if (phar_obj->archive->alias_len && NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), phar_obj->archive->alias, phar_obj->archive->alias_len))) {
-			zend_hash_str_del(&(PHAR_GLOBALS->phar_alias_map), phar_obj->archive->alias, phar_obj->archive->alias_len);
+		if (phar_obj->archive->alias_len && NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_alias_map)), phar_obj->archive->alias, phar_obj->archive->alias_len))) {
+			zend_hash_str_del(&(PHAR_G(phar_alias_map)), phar_obj->archive->alias, phar_obj->archive->alias_len);
 			readd = 1;
 		}
 
@@ -2721,13 +2721,13 @@ valid_alias:
 			phar_obj->archive->is_temporary_alias = old_temp;
 			zend_throw_exception_ex(phar_ce_PharException, 0, "%s", error);
 			if (readd) {
-				zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), oldalias, oldalias_len, phar_obj->archive);
+				zend_hash_str_add_ptr(&(PHAR_G(phar_alias_map)), oldalias, oldalias_len, phar_obj->archive);
 			}
 			efree(error);
 			RETURN_FALSE;
 		}
 
-		zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, phar_obj->archive);
+		zend_hash_str_add_ptr(&(PHAR_G(phar_alias_map)), alias, alias_len, phar_obj->archive);
 
 		if (oldalias) {
 			efree(oldalias);
diff --git a/ext/phar/stream.c b/ext/phar/stream.c
index af18fe0287..90cb13cf13 100644
--- a/ext/phar/stream.c
+++ b/ext/phar/stream.c
@@ -103,7 +103,7 @@ php_url* phar_parse_url(php_stream_wrapper *wrapper, const char *filename, const
 	if (mode[0] == 'w' || (mode[0] == 'r' && mode[1] == '+')) {
 		phar_archive_data *pphar = NULL, *phar;
 
-		if (PHAR_GLOBALS->request_init && PHAR_GLOBALS->phar_fname_map.u.flags && NULL == (pphar = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_fname_map), arch, arch_len))) {
+		if (PHAR_G(request_init) && PHAR_G(phar_fname_map.u.flags) && NULL == (pphar = zend_hash_str_find_ptr(&(PHAR_G(phar_fname_map)), arch, arch_len))) {
 			pphar = NULL;
 		}
 		if (PHAR_G(readonly) && (!pphar || !pphar->is_data)) {
@@ -701,7 +701,7 @@ static int phar_wrapper_unlink(php_stream_wrapper *wrapper, const char *url, int
 	host_len = strlen(resource->host);
 	phar_request_initialize();
 
-	pphar = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_fname_map), resource->host, host_len);
+	pphar = zend_hash_str_find_ptr(&(PHAR_G(phar_fname_map)), resource->host, host_len);
 	if (PHAR_G(readonly) && (!pphar || !pphar->is_data)) {
 		php_url_free(resource);
 		php_stream_wrapper_log_error(wrapper, options, "phar error: write operations disabled by the php.ini setting phar.readonly");
diff --git a/ext/phar/tar.c b/ext/phar/tar.c
index 0195a515bd..cab6455ffc 100644
--- a/ext/phar/tar.c
+++ b/ext/phar/tar.c
@@ -615,7 +615,7 @@ bail:
 
 	phar_request_initialize();
 
-	if (NULL == (actual = zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_fname_map), myphar->fname, fname_len, myphar))) {
+	if (NULL == (actual = zend_hash_str_add_ptr(&(PHAR_G(phar_fname_map)), myphar->fname, fname_len, myphar))) {
 		if (error) {
 			spprintf(error, 4096, "phar error: Unable to add tar-based phar \"%s\" to phar registry", fname);
 		}
@@ -631,31 +631,31 @@ bail:
 
 		myphar->is_temporary_alias = 0;
 
-		if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), actual_alias, myphar->alias_len))) {
+		if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_alias_map)), actual_alias, myphar->alias_len))) {
 			if (SUCCESS != phar_free_alias(fd_ptr, actual_alias, myphar->alias_len)) {
 				if (error) {
 					spprintf(error, 4096, "phar error: Unable to add tar-based phar \"%s\", alias is already in use", fname);
 				}
-				zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), myphar->fname, fname_len);
+				zend_hash_str_del(&(PHAR_G(phar_fname_map)), myphar->fname, fname_len);
 				return FAILURE;
 			}
 		}
 
-		zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), actual_alias, myphar->alias_len, myphar);
+		zend_hash_str_add_ptr(&(PHAR_G(phar_alias_map)), actual_alias, myphar->alias_len, myphar);
 	} else {
 		phar_archive_data *fd_ptr;
 
 		if (alias_len) {
-			if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len))) {
+			if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_alias_map)), alias, alias_len))) {
 				if (SUCCESS != phar_free_alias(fd_ptr, alias, alias_len)) {
 					if (error) {
 						spprintf(error, 4096, "phar error: Unable to add tar-based phar \"%s\", alias is already in use", fname);
 					}
-					zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), myphar->fname, fname_len);
+					zend_hash_str_del(&(PHAR_G(phar_fname_map)), myphar->fname, fname_len);
 					return FAILURE;
 				}
 			}
-			zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, myphar);
+			zend_hash_str_add_ptr(&(PHAR_G(phar_alias_map)), alias, alias_len, myphar);
 			myphar->alias = pestrndup(alias, alias_len, myphar->is_persistent);
 			myphar->alias_len = alias_len;
 		} else {
diff --git a/ext/phar/util.c b/ext/phar/util.c
index f769b012e4..1b657de67e 100644
--- a/ext/phar/util.c
+++ b/ext/phar/util.c
@@ -327,7 +327,7 @@ splitted:
 			return ret;
 		}
 
-		*pphar = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_fname_map), arch, arch_len);
+		*pphar = zend_hash_str_find_ptr(&(PHAR_G(phar_fname_map)), arch, arch_len);
 
 		if (!*pphar && PHAR_G(manifest_cached)) {
 			*pphar = zend_hash_str_find_ptr(&cached_phars, arch, arch_len);
@@ -924,8 +924,8 @@ phar_entry_info * phar_open_jit(phar_archive_data *phar, phar_entry_info *entry,
 
 PHP_PHAR_API int phar_resolve_alias(char *alias, int alias_len, char **filename, int *filename_len) /* {{{ */ {
 	phar_archive_data *fd_ptr;
-	if (PHAR_GLOBALS->phar_alias_map.u.flags
-			&& NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len))) {
+	if (PHAR_G(phar_alias_map.u.flags)
+			&& NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_alias_map)), alias, alias_len))) {
 		*filename = fd_ptr->fname;
 		*filename_len = fd_ptr->fname_len;
 		return SUCCESS;
@@ -941,7 +941,7 @@ int phar_free_alias(phar_archive_data *phar, char *alias, int alias_len) /* {{{
 	}
 
 	/* this archive has no open references, so emit an E_STRICT and remove it */
-	if (zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), phar->fname, phar->fname_len) != SUCCESS) {
+	if (zend_hash_str_del(&(PHAR_G(phar_fname_map)), phar->fname, phar->fname_len) != SUCCESS) {
 		return FAILURE;
 	}
 
@@ -983,11 +983,11 @@ int phar_get_archive(phar_archive_data **archive, char *fname, int fname_len, ch
 				return FAILURE;
 			}
 
-			if (PHAR_G(last_phar)->alias_len && NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), PHAR_G(last_phar)->alias, PHAR_G(last_phar)->alias_len))) {
-				zend_hash_str_del(&(PHAR_GLOBALS->phar_alias_map), PHAR_G(last_phar)->alias, PHAR_G(last_phar)->alias_len);
+			if (PHAR_G(last_phar)->alias_len && NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_alias_map)), PHAR_G(last_phar)->alias, PHAR_G(last_phar)->alias_len))) {
+				zend_hash_str_del(&(PHAR_G(phar_alias_map)), PHAR_G(last_phar)->alias, PHAR_G(last_phar)->alias_len);
 			}
 
-			zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, *archive);
+			zend_hash_str_add_ptr(&(PHAR_G(phar_alias_map)), alias, alias_len, *archive);
 			PHAR_G(last_alias) = alias;
 			PHAR_G(last_alias_len) = alias_len;
 		}
@@ -1002,7 +1002,7 @@ int phar_get_archive(phar_archive_data **archive, char *fname, int fname_len, ch
 	}
 
 	if (alias && alias_len) {
-		if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len))) {
+		if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_alias_map)), alias, alias_len))) {
 alias_success:
 			if (fname && (fname_len != fd_ptr->fname_len || strncmp(fname, fd_ptr->fname, fname_len))) {
 				if (error) {
@@ -1038,7 +1038,7 @@ alias_success:
 	save_len = fname_len;
 
 	if (fname && fname_len) {
-		if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_fname_map), fname, fname_len))) {
+		if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_fname_map)), fname, fname_len))) {
 			*archive = fd_ptr;
 			fd = fd_ptr;
 
@@ -1050,11 +1050,11 @@ alias_success:
 					return FAILURE;
 				}
 
-				if (fd->alias_len && NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), fd->alias, fd->alias_len))) {
-					zend_hash_str_del(&(PHAR_GLOBALS->phar_alias_map), fd->alias, fd->alias_len);
+				if (fd->alias_len && NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_alias_map)), fd->alias, fd->alias_len))) {
+					zend_hash_str_del(&(PHAR_G(phar_alias_map)), fd->alias, fd->alias_len);
 				}
 
-				zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, fd);
+				zend_hash_str_add_ptr(&(PHAR_G(phar_alias_map)), alias, alias_len, fd);
 			}
 
 			PHAR_G(last_phar) = fd;
@@ -1090,7 +1090,7 @@ alias_success:
 			return SUCCESS;
 		}
 
-		if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), save, save_len))) {
+		if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_alias_map)), save, save_len))) {
 			fd = *archive = fd_ptr;
 
 			PHAR_G(last_phar) = fd;
@@ -1127,13 +1127,13 @@ alias_success:
 		phar_unixify_path_separators(fname, fname_len);
 #endif
 
-		if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_fname_map), fname, fname_len))) {
+		if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_fname_map)), fname, fname_len))) {
 realpath_success:
 			*archive = fd_ptr;
 			fd = fd_ptr;
 
 			if (alias && alias_len) {
-				zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, fd);
+				zend_hash_str_add_ptr(&(PHAR_G(phar_alias_map)), alias, alias_len, fd);
 			}
 
 			efree(my_realpath);
@@ -2018,7 +2018,7 @@ static void phar_copy_cached_phar(phar_archive_data **pphar) /* {{{ */
 	*pphar = phar;
 
 	/* now, scan the list of persistent Phar objects referencing this phar and update the pointers */
-	ZEND_HASH_FOREACH_PTR(&PHAR_GLOBALS->phar_persist_map, objphar) {
+	ZEND_HASH_FOREACH_PTR(&PHAR_G(phar_persist_map), objphar) {
 		if (objphar->archive->fname_len == phar->fname_len && !memcmp(objphar->archive->fname, phar->fname, phar->fname_len)) {
 			objphar->archive = phar;
 		}
@@ -2032,7 +2032,7 @@ int phar_copy_on_write(phar_archive_data **pphar) /* {{{ */
 	phar_archive_data *newpphar;
 
 	ZVAL_PTR(&zv, *pphar);
-	if (NULL == (pzv = zend_hash_str_add(&(PHAR_GLOBALS->phar_fname_map), (*pphar)->fname, (*pphar)->fname_len, &zv))) {
+	if (NULL == (pzv = zend_hash_str_add(&(PHAR_G(phar_fname_map)), (*pphar)->fname, (*pphar)->fname_len, &zv))) {
 		return FAILURE;
 	}
 
@@ -2042,8 +2042,8 @@ int phar_copy_on_write(phar_archive_data **pphar) /* {{{ */
 	PHAR_G(last_phar) = NULL;
 	PHAR_G(last_phar_name) = PHAR_G(last_alias) = NULL;
 
-	if (newpphar->alias_len && NULL == zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), newpphar->alias, newpphar->alias_len, newpphar)) {
-		zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), (*pphar)->fname, (*pphar)->fname_len);
+	if (newpphar->alias_len && NULL == zend_hash_str_add_ptr(&(PHAR_G(phar_alias_map)), newpphar->alias, newpphar->alias_len, newpphar)) {
+		zend_hash_str_del(&(PHAR_G(phar_fname_map)), (*pphar)->fname, (*pphar)->fname_len);
 		return FAILURE;
 	}
 
diff --git a/ext/phar/zip.c b/ext/phar/zip.c
index 4b46f57183..f7d6c25c72 100644
--- a/ext/phar/zip.c
+++ b/ext/phar/zip.c
@@ -669,7 +669,7 @@ foundit:
 		mydata->is_data = 1;
 	}
 
-	zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len, mydata);
+	zend_hash_str_add_ptr(&(PHAR_G(phar_fname_map)), mydata->fname, fname_len, mydata);
 
 	if (actual_alias) {
 		phar_archive_data *fd_ptr;
@@ -679,19 +679,19 @@ foundit:
 				spprintf(error, 4096, "phar error: invalid alias \"%s\" in zip-based phar \"%s\"", actual_alias, fname);
 			}
 			efree(actual_alias);
-			zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len);
+			zend_hash_str_del(&(PHAR_G(phar_fname_map)), mydata->fname, fname_len);
 			return FAILURE;
 		}
 
 		mydata->is_temporary_alias = 0;
 
-		if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), actual_alias, mydata->alias_len))) {
+		if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_alias_map)), actual_alias, mydata->alias_len))) {
 			if (SUCCESS != phar_free_alias(fd_ptr, actual_alias, mydata->alias_len)) {
 				if (error) {
 					spprintf(error, 4096, "phar error: Unable to add zip-based phar \"%s\" with implicit alias, alias is already in use", fname);
 				}
 				efree(actual_alias);
-				zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len);
+				zend_hash_str_del(&(PHAR_G(phar_fname_map)), mydata->fname, fname_len);
 				return FAILURE;
 			}
 		}
@@ -702,22 +702,22 @@ foundit:
 			efree(actual_alias);
 		}
 
-		zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), actual_alias, mydata->alias_len, mydata);
+		zend_hash_str_add_ptr(&(PHAR_G(phar_alias_map)), actual_alias, mydata->alias_len, mydata);
 	} else {
 		phar_archive_data *fd_ptr;
 
 		if (alias_len) {
-			if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len))) {
+			if (NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_alias_map)), alias, alias_len))) {
 				if (SUCCESS != phar_free_alias(fd_ptr, alias, alias_len)) {
 					if (error) {
 						spprintf(error, 4096, "phar error: Unable to add zip-based phar \"%s\" with explicit alias, alias is already in use", fname);
 					}
-					zend_hash_str_del(&(PHAR_GLOBALS->phar_fname_map), mydata->fname, fname_len);
+					zend_hash_str_del(&(PHAR_G(phar_fname_map)), mydata->fname, fname_len);
 					return FAILURE;
 				}
 			}
 
-			zend_hash_str_add_ptr(&(PHAR_GLOBALS->phar_alias_map), actual_alias, mydata->alias_len, mydata);
+			zend_hash_str_add_ptr(&(PHAR_G(phar_alias_map)), actual_alias, mydata->alias_len, mydata);
 			mydata->alias = pestrndup(alias, alias_len, mydata->is_persistent);
 			mydata->alias_len = alias_len;
 		} else {