archive/php-src
1
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2025-08-16 05:58:45 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

- Remove locking support completely

Browse source
This commit is contained in:
Andi Gutmans 1999-10-01 23:26:00 +00:00
parent f67a65543d
commit 4dd47ffbc1
6 changed files with 3 additions and 59 deletions
Download patch file Download diff file Expand all files Collapse all files

5
Zend/zend.h
View file

@ -126,7 +126,6 @@ struct _zval_struct {
zvalue_value value; /* value */ zvalue_value value; /* value */
unsigned char type; /* active type */ unsigned char type; /* active type */
struct { struct {
unsigned int locks:7;
unsigned int is_ref:1; unsigned int is_ref:1;
} EA; } EA;
short refcount; short refcount;
@ -268,8 +267,7 @@ extern zend_utility_values zend_uv;
#define INIT_PZVAL(z) \ #define INIT_PZVAL(z) \
(z)->refcount = 1; \ (z)->refcount = 1; \
(z)->EA.is_ref = 0; \ (z)->EA.is_ref = 0;
(z)->EA.locks = 0;
#define MAKE_STD_ZVAL(zv) \ #define MAKE_STD_ZVAL(zv) \
zv = (zval *) emalloc(sizeof(zval)); \ zv = (zval *) emalloc(sizeof(zval)); \
@ -286,7 +284,6 @@ extern zend_utility_values zend_uv;
zval_copy_ctor(*(ppzv)); \ zval_copy_ctor(*(ppzv)); \
(*(ppzv))->refcount=1; \ (*(ppzv))->refcount=1; \
(*(ppzv))->EA.is_ref = 0; \ (*(ppzv))->EA.is_ref = 0; \
(*(ppzv))->EA.locks = 0; \
} \ } \
} }

1
Zend/zend_API.h
View file

@ -243,7 +243,6 @@ ZEND_API int add_property_stringl(zval *arg, char *key, char *str, uint length,
if (zend_hash_find(symtable, (name), (name_length), (void **) &orig_var)==SUCCESS \ if (zend_hash_find(symtable, (name), (name_length), (void **) &orig_var)==SUCCESS \
&& PZVAL_IS_REF(*orig_var)) { \ && PZVAL_IS_REF(*orig_var)) { \
var->refcount = (*orig_var)->refcount; \ var->refcount = (*orig_var)->refcount; \
var->EA.locks = (*orig_var)->EA.locks; \
var->EA.is_ref = 1; \ var->EA.is_ref = 1; \
\ \
zval_dtor(*orig_var); \ zval_dtor(*orig_var); \

1
Zend/zend_builtin_functions.c
View file

@ -233,7 +233,6 @@ ZEND_FUNCTION(each)
*tmp = *entry; *tmp = *entry;
zval_copy_ctor(tmp); zval_copy_ctor(tmp);
tmp->EA.is_ref=0; tmp->EA.is_ref=0;
tmp->EA.locks = 0;
tmp->refcount=0; tmp->refcount=0;
entry=tmp; entry=tmp;
} }

7
Zend/zend_compile.h
View file

@ -566,16 +566,9 @@ int zendlex(znode *zendlval CLS_DC);
} }
#define PZVAL_IS_REF(z) ((z)->EA.is_ref) #define PZVAL_IS_REF(z) ((z)->EA.is_ref)
#define PZVAL_IS_LOCKED(z) ((z)->EA.locks>0)
#if 0
#define PZVAL_LOCK(z) (z)->EA.locks++
#define PZVAL_UNLOCK(z) (z)->EA.locks--
#define SELECTIVE_PZVAL_LOCK(pzv, pzn) if (!((pzn)->u.EA.type & EXT_TYPE_UNUSED)) { PZVAL_LOCK(pzv); }
#else
#define PZVAL_LOCK(z) ((z)->refcount++) #define PZVAL_LOCK(z) ((z)->refcount++)
#define PZVAL_UNLOCK(z) ((z)->refcount--) #define PZVAL_UNLOCK(z) ((z)->refcount--)
#define SELECTIVE_PZVAL_LOCK(pzv, pzn) if (!((pzn)->u.EA.type & EXT_TYPE_UNUSED)) { PZVAL_LOCK(pzv); } #define SELECTIVE_PZVAL_LOCK(pzv, pzn) if (!((pzn)->u.EA.type & EXT_TYPE_UNUSED)) { PZVAL_LOCK(pzv); }
#endif
#endif /* _COMPILE_H */ #endif /* _COMPILE_H */

30
Zend/zend_execute.c
View file

@ -100,7 +100,6 @@ static inline zval *_get_zval_ptr(znode *node, temp_variable *Ts, int *should_fr
Ts[node->u.var].tmp_var = get_overloaded_property(ELS_C); Ts[node->u.var].tmp_var = get_overloaded_property(ELS_C);
Ts[node->u.var].tmp_var.refcount=1; Ts[node->u.var].tmp_var.refcount=1;
Ts[node->u.var].tmp_var.EA.is_ref=1; Ts[node->u.var].tmp_var.EA.is_ref=1;
Ts[node->u.var].tmp_var.EA.locks=0;
return &Ts[node->u.var].tmp_var; return &Ts[node->u.var].tmp_var;
break; break;
case IS_STRING_OFFSET: { case IS_STRING_OFFSET: {
@ -120,7 +119,6 @@ static inline zval *_get_zval_ptr(znode *node, temp_variable *Ts, int *should_fr
zval_ptr_dtor(&str); zval_ptr_dtor(&str);
T->tmp_var.refcount=1; T->tmp_var.refcount=1;
T->tmp_var.EA.is_ref=1; T->tmp_var.EA.is_ref=1;
T->tmp_var.EA.locks=0;
T->tmp_var.type = IS_STRING; T->tmp_var.type = IS_STRING;
return &T->tmp_var; return &T->tmp_var;
} }
@ -247,8 +245,7 @@ static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2
{ {
zval **variable_ptr_ptr = get_zval_ptr_ptr(op1, Ts, BP_VAR_W); zval **variable_ptr_ptr = get_zval_ptr_ptr(op1, Ts, BP_VAR_W);
zval *variable_ptr; zval *variable_ptr;
int previous_lock_count;
if (!variable_ptr_ptr) { if (!variable_ptr_ptr) {
switch (Ts[op1->u.var].EA.type) { switch (Ts[op1->u.var].EA.type) {
case IS_OVERLOADED_OBJECT: case IS_OVERLOADED_OBJECT:
@ -314,7 +311,6 @@ static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2
if (variable_ptr!=value) { if (variable_ptr!=value) {
short refcount=variable_ptr->refcount; short refcount=variable_ptr->refcount;
previous_lock_count = variable_ptr->EA.locks;
if (type!=IS_TMP_VAR) { if (type!=IS_TMP_VAR) {
value->refcount++; value->refcount++;
} }
@ -322,7 +318,6 @@ static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2
*variable_ptr = *value; *variable_ptr = *value;
variable_ptr->refcount = refcount; variable_ptr->refcount = refcount;
variable_ptr->EA.is_ref = 1; variable_ptr->EA.is_ref = 1;
variable_ptr->EA.locks = previous_lock_count;
if (type!=IS_TMP_VAR) { if (type!=IS_TMP_VAR) {
zendi_zval_copy_ctor(*variable_ptr); zendi_zval_copy_ctor(*variable_ptr);
zval_ptr_dtor(&value); zval_ptr_dtor(&value);
@ -340,7 +335,6 @@ static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2
value = (zval *) emalloc(sizeof(zval)); value = (zval *) emalloc(sizeof(zval));
*value = *orig_value; *value = *orig_value;
value->refcount=0; value->refcount=0;
value->EA.locks = 0;
zval_copy_ctor(value); zval_copy_ctor(value);
} }
*/ */
@ -351,11 +345,9 @@ static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2
} else if (PZVAL_IS_REF(value)) { } else if (PZVAL_IS_REF(value)) {
zval tmp = *value; zval tmp = *value;
previous_lock_count = variable_ptr->EA.locks;
tmp = *value; tmp = *value;
zval_copy_ctor(&tmp); zval_copy_ctor(&tmp);
tmp.refcount=1; tmp.refcount=1;
tmp.EA.locks = previous_lock_count;
zendi_zval_dtor(*variable_ptr); zendi_zval_dtor(*variable_ptr);
*variable_ptr = tmp; *variable_ptr = tmp;
} else { } else {
@ -368,9 +360,7 @@ static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2
case IS_TMP_VAR: case IS_TMP_VAR:
zendi_zval_dtor(*variable_ptr); zendi_zval_dtor(*variable_ptr);
value->refcount=1; value->refcount=1;
previous_lock_count = variable_ptr->EA.locks;
*variable_ptr = *value; *variable_ptr = *value;
variable_ptr->EA.locks = previous_lock_count;
break; break;
} }
} else { /* we need to split */ } else { /* we need to split */
@ -383,7 +373,6 @@ static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2
value = (zval *) emalloc(sizeof(zval)); value = (zval *) emalloc(sizeof(zval));
*value = *orig_value; *value = *orig_value;
value->refcount=0; value->refcount=0;
value->EA.locks = 0;
zval_copy_ctor(value); zval_copy_ctor(value);
} }
*/ */
@ -394,7 +383,6 @@ static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2
*variable_ptr = *value; *variable_ptr = *value;
zval_copy_ctor(variable_ptr); zval_copy_ctor(variable_ptr);
variable_ptr->refcount=1; variable_ptr->refcount=1;
variable_ptr->EA.locks = 0;
break; break;
} }
*variable_ptr_ptr = value; *variable_ptr_ptr = value;
@ -403,7 +391,6 @@ static inline void zend_assign_to_variable(znode *result, znode *op1, znode *op2
case IS_TMP_VAR: case IS_TMP_VAR:
(*variable_ptr_ptr) = (zval *) emalloc(sizeof(zval)); (*variable_ptr_ptr) = (zval *) emalloc(sizeof(zval));
value->refcount=1; value->refcount=1;
value->EA.locks = 0;
**variable_ptr_ptr = *value; **variable_ptr_ptr = *value;
break; break;
} }
@ -650,7 +637,6 @@ static inline void zend_fetch_dimension_address(znode *result, znode *op1, znode
if (container->refcount>0) { if (container->refcount>0) {
container = *container_ptr = (zval *) emalloc(sizeof(zval)); container = *container_ptr = (zval *) emalloc(sizeof(zval));
container->EA.is_ref=0; container->EA.is_ref=0;
container->EA.locks = 0;
} }
container->refcount=1; container->refcount=1;
} }
@ -819,7 +805,6 @@ static inline void zend_fetch_property_address(znode *result, znode *op1, znode
if (container->refcount>0) { if (container->refcount>0) {
container = *container_ptr = (zval *) emalloc(sizeof(zval)); container = *container_ptr = (zval *) emalloc(sizeof(zval));
container->EA.is_ref=0; container->EA.is_ref=0;
container->EA.locks = 0;
} }
container->refcount=1; container->refcount=1;
} }
@ -947,7 +932,6 @@ void execute(zend_op_array *op_array ELS_DC)
globals->refcount=1; globals->refcount=1;
globals->EA.is_ref=1; globals->EA.is_ref=1;
globals->EA.locks = 0;
globals->type = IS_ARRAY; globals->type = IS_ARRAY;
globals->value.ht = &EG(symbol_table); globals->value.ht = &EG(symbol_table);
if (zend_hash_add(EG(active_symbol_table), "GLOBALS", sizeof("GLOBALS"), &globals, sizeof(zval *), NULL)==FAILURE) { if (zend_hash_add(EG(active_symbol_table), "GLOBALS", sizeof("GLOBALS"), &globals, sizeof(zval *), NULL)==FAILURE) {
@ -1055,7 +1039,6 @@ binary_op_addr:
/* Fall through */ /* Fall through */
binary_assign_op_addr: { binary_assign_op_addr: {
zval **var_ptr = get_zval_ptr_ptr(&opline->op1, Ts, BP_VAR_RW); zval **var_ptr = get_zval_ptr_ptr(&opline->op1, Ts, BP_VAR_RW);
int previous_lock_count;
if (!var_ptr) { if (!var_ptr) {
zend_error(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); zend_error(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
@ -1076,12 +1059,9 @@ binary_assign_op_addr: {
**var_ptr = *orig_var; **var_ptr = *orig_var;
zendi_zval_copy_ctor(**var_ptr); zendi_zval_copy_ctor(**var_ptr);
(*var_ptr)->refcount=1; (*var_ptr)->refcount=1;
(*var_ptr)->EA.locks = 0;
} }
} }
previous_lock_count = (*var_ptr)->EA.locks;
EG(binary_op)(*var_ptr, *var_ptr, get_zval_ptr(&opline->op2, Ts, &EG(free_op2), BP_VAR_R)); EG(binary_op)(*var_ptr, *var_ptr, get_zval_ptr(&opline->op2, Ts, &EG(free_op2), BP_VAR_R));
(*var_ptr)->EA.locks = previous_lock_count;
Ts[opline->result.u.var].var.ptr_ptr = var_ptr; Ts[opline->result.u.var].var.ptr_ptr = var_ptr;
SELECTIVE_PZVAL_LOCK(*var_ptr, &opline->result); SELECTIVE_PZVAL_LOCK(*var_ptr, &opline->result);
FREE_OP(&opline->op2, EG(free_op2)); FREE_OP(&opline->op2, EG(free_op2));
@ -1124,7 +1104,6 @@ binary_assign_op_addr: {
**var_ptr = *orig_var; **var_ptr = *orig_var;
zendi_zval_copy_ctor(**var_ptr); zendi_zval_copy_ctor(**var_ptr);
(*var_ptr)->refcount=1; (*var_ptr)->refcount=1;
(*var_ptr)->EA.locks = 0;
} }
} }
incdec_op(*var_ptr); incdec_op(*var_ptr);
@ -1511,7 +1490,6 @@ do_fcall_common:
} }
object.ptr->refcount = 1; object.ptr->refcount = 1;
object.ptr->EA.is_ref = 1; object.ptr->EA.is_ref = 1;
object.ptr->EA.locks = 0;
} }
*this_ptr = object.ptr; *this_ptr = object.ptr;
object.ptr->refcount++; object.ptr->refcount++;
@ -1592,14 +1570,12 @@ do_fcall_common:
var_uninit(varptr); var_uninit(varptr);
varptr->refcount=0; varptr->refcount=0;
varptr->EA.is_ref=0; varptr->EA.is_ref=0;
varptr->EA.locks = 0;
} else if (PZVAL_IS_REF(varptr)) { } else if (PZVAL_IS_REF(varptr)) {
zval *original_var = varptr; zval *original_var = varptr;
varptr = (zval *) emalloc(sizeof(zval)); varptr = (zval *) emalloc(sizeof(zval));
*varptr = *original_var; *varptr = *original_var;
varptr->EA.is_ref = 0; varptr->EA.is_ref = 0;
varptr->EA.locks = 0;
varptr->refcount = 0; varptr->refcount = 0;
zval_copy_ctor(varptr); zval_copy_ctor(varptr);
} }
@ -1624,7 +1600,6 @@ send_by_ref:
zval_copy_ctor(varptr); zval_copy_ctor(varptr);
} }
varptr->EA.is_ref = 1; varptr->EA.is_ref = 1;
varptr->EA.locks = 0;
/* at the end of this code refcount is always 1 */ /* at the end of this code refcount is always 1 */
} }
varptr->refcount++; varptr->refcount++;
@ -1669,7 +1644,6 @@ send_by_ref:
} }
default_value->refcount=0; default_value->refcount=0;
default_value->EA.is_ref=0; default_value->EA.is_ref=0;
default_value->EA.locks = 0;
param = &default_value; param = &default_value;
assignment_value = default_value; assignment_value = default_value;
} else { } else {
@ -1786,8 +1760,6 @@ send_by_ref:
object_init_ex(&Ts[opline->result.u.var].tmp_var, ce); object_init_ex(&Ts[opline->result.u.var].tmp_var, ce);
Ts[opline->result.u.var].tmp_var.refcount=1; Ts[opline->result.u.var].tmp_var.refcount=1;
Ts[opline->result.u.var].tmp_var.EA.is_ref=1; Ts[opline->result.u.var].tmp_var.EA.is_ref=1;
Ts[opline->result.u.var].tmp_var.EA.locks=0;
zval_dtor(&class_name); zval_dtor(&class_name);
FREE_OP(&opline->op1, EG(free_op1)); FREE_OP(&opline->op1, EG(free_op1));
} }

18
Zend/zend_execute_API.c
View file

@ -85,11 +85,9 @@ void init_executor(CLS_D ELS_DC)
var_uninit(&EG(error_zval)); var_uninit(&EG(error_zval));
EG(uninitialized_zval).refcount = 1; EG(uninitialized_zval).refcount = 1;
EG(uninitialized_zval).EA.is_ref=0; EG(uninitialized_zval).EA.is_ref=0;
EG(uninitialized_zval).EA.locks = 0;
EG(uninitialized_zval_ptr)=&EG(uninitialized_zval); EG(uninitialized_zval_ptr)=&EG(uninitialized_zval);
EG(error_zval).refcount = 1; EG(error_zval).refcount = 1;
EG(error_zval).EA.is_ref=0; EG(error_zval).EA.is_ref=0;
EG(error_zval).EA.locks = 0;
EG(error_zval_ptr)=&EG(error_zval); EG(error_zval_ptr)=&EG(error_zval);
EG(destroying_function_symbol_table) = 0; EG(destroying_function_symbol_table) = 0;
zend_ptr_stack_init(&EG(arg_types_stack)); zend_ptr_stack_init(&EG(arg_types_stack));
@ -205,8 +203,6 @@ ZEND_API inline void safe_free_zval_ptr(zval *p)
ZEND_API int _zval_ptr_dtor(zval **zval_ptr ZEND_FILE_LINE_DC) ZEND_API int _zval_ptr_dtor(zval **zval_ptr ZEND_FILE_LINE_DC)
{ {
int locked = (*zval_ptr)->EA.locks;
#if DEBUG_ZEND>=2 #if DEBUG_ZEND>=2
printf("Reducing refcount for %x (%x): %d->%d\n", *zval_ptr, zval_ptr, (*zval_ptr)->refcount, (*zval_ptr)->refcount-1); printf("Reducing refcount for %x (%x): %d->%d\n", *zval_ptr, zval_ptr, (*zval_ptr)->refcount, (*zval_ptr)->refcount-1);
#endif #endif
@ -215,17 +211,7 @@ ZEND_API int _zval_ptr_dtor(zval **zval_ptr ZEND_FILE_LINE_DC)
zval_dtor(*zval_ptr); zval_dtor(*zval_ptr);
safe_free_zval_ptr(*zval_ptr); safe_free_zval_ptr(*zval_ptr);
} }
if (locked) { return 1;
ELS_FETCH();
if (EG(destroying_function_symbol_table)) {
return 1;
} else {
return 0; /* don't kill the container bucket */
}
} else {
return 1;
}
} }
@ -347,7 +333,6 @@ int call_user_function_ex(HashTable *function_table, zval *object, zval *functio
*new_zval = **params[i]; *new_zval = **params[i];
zval_copy_ctor(new_zval); zval_copy_ctor(new_zval);
new_zval->refcount = 1; new_zval->refcount = 1;
new_zval->EA.locks = 0;
(*params[i])->refcount--; (*params[i])->refcount--;
*params[i] = new_zval; *params[i] = new_zval;
} }
@ -489,7 +474,6 @@ ZEND_API inline void zend_assign_to_variable_reference(znode *result, zval **var
} }
value_ptr->refcount = 1; value_ptr->refcount = 1;
value_ptr->EA.is_ref = 1; value_ptr->EA.is_ref = 1;
value_ptr->EA.locks = 0;
} }
*variable_ptr_ptr = value_ptr; *variable_ptr_ptr = value_ptr;