Skip to content

Commit 5408d96

Browse files
cmb69cmb69
committed
Merge branch 'master' of http://git.php.net/repository/php-src 
2 parents a291d92 + c622cc4 commit 5408d96

File tree

7 files changed

+28
-52
lines changed

7 files changed

+28
-52
lines changed

‎Zend/Zend.m4

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -370,10 +370,10 @@ AC_CHECK_FUNCS(mremap)
370370
371371
372372
AC_ARG_ENABLE(zend-signals,
373-
[ --enable-zend-signals Use zend signal handling],[
373+
[ --disable-zend-signals whether to enable zend signal handling],[
374374
ZEND_SIGNALS=$enableval
375375
],[
376-
ZEND_SIGNALS=no
376+
ZEND_SIGNALS=yes
377377
])
378378
379379
AC_CHECK_FUNC(sigaction, [

‎Zend/zend.h

Lines changed: 2 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -42,16 +42,8 @@
4242
#include "zend_smart_str_public.h"
4343
#include "zend_signal.h"
4444

45-
#ifndef ZEND_SIGNALS
46-
/* block/unblock interruptions callbacks might be used by SAPI, and were used
47-
* by mod_php for Apache 1, but now they are not usefull anymore.
48-
*/
49-
# define HANDLE_BLOCK_INTERRUPTIONS()
50-
# define HANDLE_UNBLOCK_INTERRUPTIONS()
51-
#else
52-
# define HANDLE_BLOCK_INTERRUPTIONS() ZEND_SIGNAL_BLOCK_INTERRUPTIONS()
53-
# define HANDLE_UNBLOCK_INTERRUPTIONS() ZEND_SIGNAL_UNBLOCK_INTERRUPTIONS()
54-
#endif
45+
#define HANDLE_BLOCK_INTERRUPTIONS() ZEND_SIGNAL_BLOCK_INTERRUPTIONS()
46+
#define HANDLE_UNBLOCK_INTERRUPTIONS() ZEND_SIGNAL_UNBLOCK_INTERRUPTIONS()
5547

5648
#define INTERNAL_FUNCTION_PARAMETERS zend_execute_data *execute_data, zval *return_value
5749
#define INTERNAL_FUNCTION_PARAM_PASSTHRU execute_data, return_value

‎Zend/zend_hash.c

Lines changed: 0 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -191,10 +191,8 @@ static void ZEND_FASTCALL zend_hash_packed_grow(HashTable *ht)
191191
if (ht->nTableSize >= HT_MAX_SIZE) {
192192
zend_error_noreturn(E_ERROR, "Possible integer overflow in memory allocation (%zu * %zu + %zu)", ht->nTableSize * 2, sizeof(Bucket), sizeof(Bucket));
193193
}
194-
HANDLE_BLOCK_INTERRUPTIONS();
195194
ht->nTableSize += ht->nTableSize;
196195
HT_SET_DATA_ADDR(ht, perealloc2(HT_GET_DATA_ADDR(ht), HT_SIZE(ht), HT_USED_SIZE(ht), ht->u.flags & HASH_FLAG_PERSISTENT));
197-
HANDLE_UNBLOCK_INTERRUPTIONS();
198196
}
199197

200198
ZEND_API void ZEND_FASTCALL zend_hash_real_init(HashTable *ht, zend_bool packed)
@@ -211,15 +209,13 @@ ZEND_API void ZEND_FASTCALL zend_hash_packed_to_hash(HashTable *ht)
211209
Bucket *old_buckets = ht->arData;
212210

213211
HT_ASSERT(GC_REFCOUNT(ht) == 1);
214-
HANDLE_BLOCK_INTERRUPTIONS();
215212
ht->u.flags &= ~HASH_FLAG_PACKED;
216213
new_data = pemalloc(HT_SIZE_EX(ht->nTableSize, -ht->nTableSize), (ht)->u.flags & HASH_FLAG_PERSISTENT);
217214
ht->nTableMask = -ht->nTableSize;
218215
HT_SET_DATA_ADDR(ht, new_data);
219216
memcpy(ht->arData, old_buckets, sizeof(Bucket) * ht->nNumUsed);
220217
pefree(old_data, (ht)->u.flags & HASH_FLAG_PERSISTENT);
221218
zend_hash_rehash(ht);
222-
HANDLE_UNBLOCK_INTERRUPTIONS();
223219
}
224220

225221
ZEND_API void ZEND_FASTCALL zend_hash_to_packed(HashTable *ht)
@@ -228,15 +224,13 @@ ZEND_API void ZEND_FASTCALL zend_hash_to_packed(HashTable *ht)
228224
Bucket *old_buckets = ht->arData;
229225

230226
HT_ASSERT(GC_REFCOUNT(ht) == 1);
231-
HANDLE_BLOCK_INTERRUPTIONS();
232227
new_data = pemalloc(HT_SIZE_EX(ht->nTableSize, HT_MIN_MASK), (ht)->u.flags & HASH_FLAG_PERSISTENT);
233228
ht->u.flags |= HASH_FLAG_PACKED | HASH_FLAG_STATIC_KEYS;
234229
ht->nTableMask = HT_MIN_MASK;
235230
HT_SET_DATA_ADDR(ht, new_data);
236231
HT_HASH_RESET_PACKED(ht);
237232
memcpy(ht->arData, old_buckets, sizeof(Bucket) * ht->nNumUsed);
238233
pefree(old_data, (ht)->u.flags & HASH_FLAG_PERSISTENT);
239-
HANDLE_UNBLOCK_INTERRUPTIONS();
240234
}
241235

242236
ZEND_API void ZEND_FASTCALL _zend_hash_init_ex(HashTable *ht, uint32_t nSize, dtor_func_t pDestructor, zend_bool persistent, zend_bool bApplyProtection ZEND_FILE_LINE_DC)
@@ -260,26 +254,22 @@ ZEND_API void ZEND_FASTCALL zend_hash_extend(HashTable *ht, uint32_t nSize, zend
260254
if (packed) {
261255
ZEND_ASSERT(ht->u.flags & HASH_FLAG_PACKED);
262256
if (nSize > ht->nTableSize) {
263-
HANDLE_BLOCK_INTERRUPTIONS();
264257
ht->nTableSize = zend_hash_check_size(nSize);
265258
HT_SET_DATA_ADDR(ht, perealloc2(HT_GET_DATA_ADDR(ht), HT_SIZE(ht), HT_USED_SIZE(ht), ht->u.flags & HASH_FLAG_PERSISTENT));
266-
HANDLE_UNBLOCK_INTERRUPTIONS();
267259
}
268260
} else {
269261
ZEND_ASSERT(!(ht->u.flags & HASH_FLAG_PACKED));
270262
if (nSize > ht->nTableSize) {
271263
void *new_data, *old_data = HT_GET_DATA_ADDR(ht);
272264
Bucket *old_buckets = ht->arData;
273265
nSize = zend_hash_check_size(nSize);
274-
HANDLE_BLOCK_INTERRUPTIONS();
275266
new_data = pemalloc(HT_SIZE_EX(nSize, -nSize), ht->u.flags & HASH_FLAG_PERSISTENT);
276267
ht->nTableSize = nSize;
277268
ht->nTableMask = -ht->nTableSize;
278269
HT_SET_DATA_ADDR(ht, new_data);
279270
memcpy(ht->arData, old_buckets, sizeof(Bucket) * ht->nNumUsed);
280271
pefree(old_data, ht->u.flags & HASH_FLAG_PERSISTENT);
281272
zend_hash_rehash(ht);
282-
HANDLE_UNBLOCK_INTERRUPTIONS();
283273
}
284274
}
285275
}
@@ -591,20 +581,17 @@ static zend_always_inline zval *_zend_hash_add_or_update_i(HashTable *ht, zend_s
591581
data = Z_INDIRECT_P(data);
592582
}
593583
}
594-
HANDLE_BLOCK_INTERRUPTIONS();
595584
if (ht->pDestructor) {
596585
ht->pDestructor(data);
597586
}
598587
ZVAL_COPY_VALUE(data, pData);
599-
HANDLE_UNBLOCK_INTERRUPTIONS();
600588
return data;
601589
}
602590
}
603591

604592
ZEND_HASH_IF_FULL_DO_RESIZE(ht); /* If the Hash table is full, resize it */
605593

606594
add_to_hash:
607-
HANDLE_BLOCK_INTERRUPTIONS();
608595
idx = ht->nNumUsed++;
609596
ht->nNumOfElements++;
610597
if (ht->nInternalPointer == HT_INVALID_IDX) {
@@ -623,7 +610,6 @@ static zend_always_inline zval *_zend_hash_add_or_update_i(HashTable *ht, zend_s
623610
nIndex = h | ht->nTableMask;
624611
Z_NEXT(p->val) = HT_HASH(ht, nIndex);
625612
HT_HASH(ht, nIndex) = HT_IDX_TO_HASH(idx);
626-
HANDLE_UNBLOCK_INTERRUPTIONS();
627613

628614
return &p->val;
629615
}
@@ -762,7 +748,6 @@ static zend_always_inline zval *_zend_hash_index_add_or_update_i(HashTable *ht,
762748
}
763749

764750
add_to_packed:
765-
HANDLE_BLOCK_INTERRUPTIONS();
766751
/* incremental initialization of empty Buckets */
767752
if ((flag & (HASH_ADD_NEW|HASH_ADD_NEXT)) == (HASH_ADD_NEW|HASH_ADD_NEXT)) {
768753
ht->nNumUsed = h + 1;
@@ -788,8 +773,6 @@ static zend_always_inline zval *_zend_hash_index_add_or_update_i(HashTable *ht,
788773
p->key = NULL;
789774
ZVAL_COPY_VALUE(&p->val, pData);
790775

791-
HANDLE_UNBLOCK_INTERRUPTIONS();
792-
793776
return &p->val;
794777

795778
convert_to_hash:
@@ -801,12 +784,10 @@ static zend_always_inline zval *_zend_hash_index_add_or_update_i(HashTable *ht,
801784
return NULL;
802785
}
803786
ZEND_ASSERT(&p->val != pData);
804-
HANDLE_BLOCK_INTERRUPTIONS();
805787
if (ht->pDestructor) {
806788
ht->pDestructor(&p->val);
807789
}
808790
ZVAL_COPY_VALUE(&p->val, pData);
809-
HANDLE_UNBLOCK_INTERRUPTIONS();
810791
if ((zend_long)h >= (zend_long)ht->nNextFreeElement) {
811792
ht->nNextFreeElement = h < ZEND_LONG_MAX ? h + 1 : ZEND_LONG_MAX;
812793
}
@@ -817,7 +798,6 @@ static zend_always_inline zval *_zend_hash_index_add_or_update_i(HashTable *ht,
817798
ZEND_HASH_IF_FULL_DO_RESIZE(ht); /* If the Hash table is full, resize it */
818799

819800
add_to_hash:
820-
HANDLE_BLOCK_INTERRUPTIONS();
821801
idx = ht->nNumUsed++;
822802
ht->nNumOfElements++;
823803
if (ht->nInternalPointer == HT_INVALID_IDX) {
@@ -834,7 +814,6 @@ static zend_always_inline zval *_zend_hash_index_add_or_update_i(HashTable *ht,
834814
ZVAL_COPY_VALUE(&p->val, pData);
835815
Z_NEXT(p->val) = HT_HASH(ht, nIndex);
836816
HT_HASH(ht, nIndex) = HT_IDX_TO_HASH(idx);
837-
HANDLE_UNBLOCK_INTERRUPTIONS();
838817

839818
return &p->val;
840819
}
@@ -876,23 +855,19 @@ static void ZEND_FASTCALL zend_hash_do_resize(HashTable *ht)
876855
HT_ASSERT(GC_REFCOUNT(ht) == 1);
877856

878857
if (ht->nNumUsed > ht->nNumOfElements + (ht->nNumOfElements >> 5)) { /* additional term is there to amortize the cost of compaction */
879-
HANDLE_BLOCK_INTERRUPTIONS();
880858
zend_hash_rehash(ht);
881-
HANDLE_UNBLOCK_INTERRUPTIONS();
882859
} else if (ht->nTableSize < HT_MAX_SIZE) { /* Let's double the table size */
883860
void *new_data, *old_data = HT_GET_DATA_ADDR(ht);
884861
uint32_t nSize = ht->nTableSize + ht->nTableSize;
885862
Bucket *old_buckets = ht->arData;
886863

887-
HANDLE_BLOCK_INTERRUPTIONS();
888864
new_data = pemalloc(HT_SIZE_EX(nSize, -nSize), ht->u.flags & HASH_FLAG_PERSISTENT);
889865
ht->nTableSize = nSize;
890866
ht->nTableMask = -ht->nTableSize;
891867
HT_SET_DATA_ADDR(ht, new_data);
892868
memcpy(ht->arData, old_buckets, sizeof(Bucket) * ht->nNumUsed);
893869
pefree(old_data, ht->u.flags & HASH_FLAG_PERSISTENT);
894870
zend_hash_rehash(ht);
895-
HANDLE_UNBLOCK_INTERRUPTIONS();
896871
} else {
897872
zend_error_noreturn(E_ERROR, "Possible integer overflow in memory allocation (%zu * %zu + %zu)", ht->nTableSize * 2, sizeof(Bucket) + sizeof(uint32_t), sizeof(Bucket));
898873
}
@@ -984,7 +959,6 @@ ZEND_API int ZEND_FASTCALL zend_hash_rehash(HashTable *ht)
984959

985960
static zend_always_inline void _zend_hash_del_el_ex(HashTable *ht, uint32_t idx, Bucket *p, Bucket *prev)
986961
{
987-
HANDLE_BLOCK_INTERRUPTIONS();
988962
if (!(ht->u.flags & HASH_FLAG_PACKED)) {
989963
if (prev) {
990964
Z_NEXT(prev->val) = Z_NEXT(p->val);
@@ -1027,7 +1001,6 @@ static zend_always_inline void _zend_hash_del_el_ex(HashTable *ht, uint32_t idx,
10271001
} else {
10281002
ZVAL_UNDEF(&p->val);
10291003
}
1030-
HANDLE_UNBLOCK_INTERRUPTIONS();
10311004
}
10321005

10331006
static zend_always_inline void _zend_hash_del_el(HashTable *ht, uint32_t idx, Bucket *p)
@@ -2296,7 +2269,6 @@ ZEND_API int ZEND_FASTCALL zend_hash_sort_ex(HashTable *ht, sort_func_t sort, co
22962269
(swap_func_t)(renumber? zend_hash_bucket_renum_swap :
22972270
((ht->u.flags & HASH_FLAG_PACKED) ? zend_hash_bucket_packed_swap : zend_hash_bucket_swap)));
22982271

2299-
HANDLE_BLOCK_INTERRUPTIONS();
23002272
ht->nNumUsed = i;
23012273
ht->nInternalPointer = 0;
23022274

@@ -2333,8 +2305,6 @@ ZEND_API int ZEND_FASTCALL zend_hash_sort_ex(HashTable *ht, sort_func_t sort, co
23332305
}
23342306
}
23352307

2336-
HANDLE_UNBLOCK_INTERRUPTIONS();
2337-
23382308
return SUCCESS;
23392309
}
23402310

‎Zend/zend_string.c

Lines changed: 0 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -161,7 +161,6 @@ static zend_string *zend_new_interned_string_int(zend_string *str)
161161
void *old_data = HT_GET_DATA_ADDR(&CG(interned_strings));
162162
Bucket *old_buckets = CG(interned_strings).arData;
163163

164-
HANDLE_BLOCK_INTERRUPTIONS();
165164
CG(interned_strings).nTableSize += CG(interned_strings).nTableSize;
166165
CG(interned_strings).nTableMask = -CG(interned_strings).nTableSize;
167166
new_data = malloc(HT_SIZE(&CG(interned_strings)));
@@ -175,12 +174,9 @@ static zend_string *zend_new_interned_string_int(zend_string *str)
175174
CG(interned_strings).nTableSize = CG(interned_strings).nTableSize >> 1;
176175
CG(interned_strings).nTableMask = -CG(interned_strings).nTableSize;
177176
}
178-
HANDLE_UNBLOCK_INTERRUPTIONS();
179177
}
180178
}
181179

182-
HANDLE_BLOCK_INTERRUPTIONS();
183-
184180
idx = CG(interned_strings).nNumUsed++;
185181
CG(interned_strings).nNumOfElements++;
186182
p = CG(interned_strings).arData + idx;
@@ -192,8 +188,6 @@ static zend_string *zend_new_interned_string_int(zend_string *str)
192188
Z_NEXT(p->val) = HT_HASH(&CG(interned_strings), nIndex);
193189
HT_HASH(&CG(interned_strings), nIndex) = HT_IDX_TO_HASH(idx);
194190

195-
HANDLE_UNBLOCK_INTERRUPTIONS();
196-
197191
return str;
198192
#else
199193
return str;

0 commit comments

Comments
 (0)