Changeset 832 for trunk/xcache.c


Ignore:
Timestamp:
2012-03-23T17:17:34+01:00 (2 years ago)
Author:
moo
Message:

fix DIR FILE handling in literal. path resolve is still in todo

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/xcache.c

    r827 r832  
    11781178/* {{{ Constant Usage */ 
    11791179#ifdef ZEND_ENGINE_2_4 
     1180#   define xcache_literal_is_dir  1 
     1181#   define xcache_literal_is_file 2 
    11801182#else 
    11811183#   define xcache_op1_is_file 1 
     
    11931195static void xc_collect_op_array_info(xc_entry_t *xce, xc_entry_data_php_t *php, xc_const_usage_t *usage, xc_op_array_info_t *op_array_info, zend_op_array *op_array TSRMLS_DC) /* {{{ */ 
    11941196{ 
    1195 #ifdef ZEND_ENGINE_2_4 
    1196     int oplineno; 
    1197 #else 
    1198     int oplineno; 
    1199 #endif 
    1200     xc_vector_t vector_int; 
    1201  
    1202     xc_vector_init(int, &vector_int); 
    1203  
    1204 #ifdef ZEND_ENGINE_2_4 
    1205 #else 
    1206 #define XCACHE_CHECK_OP(type, op) \ 
     1197    int i; 
     1198    xc_vector_t details; 
     1199 
     1200    xc_vector_init(xc_op_array_info_detail_t, &details); 
     1201 
     1202#define XCACHE_ANALYZE_LITERAL(type) \ 
     1203    if (zend_binary_strcmp(Z_STRVAL(literal->constant), Z_STRLEN(literal->constant), xce->type##path, xce->type##path_len) == 0) { \ 
     1204        usage->type##path_used = 1; \ 
     1205        literalinfo |= xcache_##literal##_is_##type; \ 
     1206    } 
     1207 
     1208#define XCACHE_U_ANALYZE_LITERAL(type) \ 
     1209    if (zend_u_##binary_strcmp(Z_USTRVAL(literal->constant), Z_USTRLEN(literal->constant), xce->u##type##path, xce->u##type##path_len) == 0) { \ 
     1210        usage->u##type##path_used = 1; \ 
     1211        literalinfo |= xcache_##literal##_is_##type; \ 
     1212    } 
     1213 
     1214#define XCACHE_ANALYZE_OP(type, op) \ 
    12071215    if (zend_binary_strcmp(Z_STRVAL(Z_OP_CONSTANT(opline->op)), Z_STRLEN(Z_OP_CONSTANT(opline->op)), xce->type##path, xce->type##path_len) == 0) { \ 
    12081216        usage->type##path_used = 1; \ 
     
    12101218    } 
    12111219 
    1212 #define XCACHE_U_CHECK_OP(type, op) \ 
     1220#define XCACHE_U_ANALYZE_OP(type, op) \ 
    12131221    if (zend_u_##binary_strcmp(Z_USTRVAL(Z_OP_CONSTANT(opline->op)), Z_USTRLEN(Z_OP_CONSTANT(opline->op)), xce->u##type##path, xce->u##type##path_len) == 0) { \ 
    12141222        usage->u##type##path_used = 1; \ 
     
    12161224    } 
    12171225 
    1218     for (oplineno = 0; oplineno < op_array->last; oplineno++) { 
    1219         zend_op *opline = &op_array->opcodes[oplineno]; 
    1220         int oplineinfo = 0; 
     1226#ifdef ZEND_ENGINE_2_4 
     1227    for (i = 0; i < op_array->last_literal; i++) { 
     1228        zend_literal *literal = &op_array->literals[i]; 
     1229        zend_uint literalinfo = 0; 
     1230        if (Z_TYPE(literal->constant) == IS_STRING) { 
     1231            XCACHE_ANALYZE_LITERAL(file) 
     1232            else XCACHE_ANALYZE_LITERAL(dir) 
     1233        } 
     1234#ifdef IS_UNICODE 
     1235        else if (Z_TYPE(literal->constant) == IS_UNICODE) { 
     1236            XCACHE_U_ANALYZE_LITERAL(file) 
     1237            else XCACHE_U_ANALYZE_LITERAL(dir) 
     1238        } 
     1239#endif 
     1240        if (literalinfo) { 
     1241            xc_op_array_info_detail_t detail; 
     1242            detail.index = i; 
     1243            detail.info  = literalinfo; 
     1244            xc_vector_add(xc_op_array_info_detail_t, &details, detail); 
     1245        } 
     1246    } 
     1247 
     1248    op_array_info->literalinfo_cnt = details.cnt; 
     1249    op_array_info->literalinfos    = xc_vector_detach(xc_op_array_info_detail_t, &details); 
     1250#else /* ZEND_ENGINE_2_4 */ 
     1251    for (i = 0; i < op_array->last; i++) { 
     1252        zend_op *opline = &op_array->opcodes[i]; 
     1253        zend_uint oplineinfo = 0; 
    12211254        if (Z_OP_TYPE(opline->op1) == IS_CONST) { 
    12221255            if (Z_TYPE(Z_OP_CONSTANT(opline->op1)) == IS_STRING) { 
    1223                 XCACHE_CHECK_OP(file, op1) 
    1224                 else XCACHE_CHECK_OP(dir, op1) 
    1225             } 
    1226  
     1256                XCACHE_ANALYZE_OP(file, op1) 
     1257                else XCACHE_ANALYZE_OP(dir, op1) 
     1258            } 
    12271259#ifdef IS_UNICODE 
    12281260            else if (Z_TYPE(Z_OP_CONSTANT(opline->op1)) == IS_UNICODE) { 
    1229                 XCACHE_U_CHECK_OP(file, op1) 
    1230                 else XCACHE_U_CHECK_OP(dir, op1) 
    1231             } 
    1232 #endif 
    1233         } 
     1261                XCACHE_U_ANALYZE_OP(file, op1) 
     1262                else XCACHE_U_ANALYZE_OP(dir, op1) 
     1263            } 
     1264#endif 
     1265        } 
     1266 
    12341267        if (Z_OP_TYPE(opline->op2) == IS_CONST) { 
    12351268            if (Z_TYPE(Z_OP_CONSTANT(opline->op2)) == IS_STRING) { 
    1236                 XCACHE_CHECK_OP(file, op2) 
    1237                 else XCACHE_CHECK_OP(dir, op2) 
    1238             } 
    1239  
     1269                XCACHE_ANALYZE_OP(file, op2) 
     1270                else XCACHE_ANALYZE_OP(dir, op2) 
     1271            } 
    12401272#ifdef IS_UNICODE 
    12411273            else if (Z_TYPE(Z_OP_CONSTANT(opline->op2)) == IS_UNICODE) { 
    1242                 XCACHE_U_CHECK_OP(file, op2) 
    1243                 else XCACHE_U_CHECK_OP(dir, op2) 
    1244             } 
    1245 #endif 
    1246         } 
     1274                XCACHE_U_ANALYZE_OP(file, op2) 
     1275                else XCACHE_U_ANALYZE_OP(dir, op2) 
     1276            } 
     1277#endif 
     1278        } 
     1279 
    12471280        if (oplineinfo) { 
    1248             xc_vector_add(int, &vector_int, oplineno); 
    1249             xc_vector_add(int, &vector_int, oplineinfo); 
    1250         } 
    1251     } 
    1252  
    1253     op_array_info->oplineinfo_cnt = vector_int.cnt; 
    1254     op_array_info->oplineinfos    = xc_vector_detach(int, &vector_int); 
    1255 #endif 
    1256     xc_vector_free(int, &vector_int); 
    1257 } 
    1258 /* }}} */ 
    1259 void xc_fix_op_array_info(const xc_entry_t *xce, const xc_entry_data_php_t *php, zend_op_array *op_array, int copy, const xc_op_array_info_t *op_array_info TSRMLS_DC) /* {{{ */ 
    1260 { 
     1281            xc_op_array_info_detail_t detail; 
     1282            detail.index = i; 
     1283            detail.info  = oplineinfo; 
     1284            xc_vector_add(xc_op_array_info_detail_t, &details, detail); 
     1285        } 
     1286    } 
     1287 
     1288    op_array_info->oplineinfo_cnt = details.cnt; 
     1289    op_array_info->oplineinfos    = xc_vector_detach(xc_op_array_info_detail_t, &details); 
     1290#endif /* ZEND_ENGINE_2_4 */ 
     1291    xc_vector_free(xc_op_array_info_detail_t, &details); 
     1292} 
     1293/* }}} */ 
     1294void xc_fix_op_array_info(const xc_entry_t *xce, const xc_entry_data_php_t *php, zend_op_array *op_array, int shallow_copy, const xc_op_array_info_t *op_array_info TSRMLS_DC) /* {{{ */ 
     1295{ 
     1296    int i; 
     1297 
    12611298#ifdef ZEND_ENGINE_2_4 
     1299    for (i = 0; i < op_array_info->literalinfo_cnt; ++i) { 
     1300        int index = op_array_info->literalinfos[i].index; 
     1301        int literalinfo = op_array_info->literalinfos[i].info; 
     1302        zend_literal *literal = &op_array->literals[index]; 
     1303        if ((literalinfo & xcache_literal_is_file)) { 
     1304            if (!shallow_copy) { 
     1305                efree(Z_STRVAL(literal->constant)); 
     1306            } 
     1307            if (Z_TYPE(literal->constant) == IS_STRING) { 
     1308                assert(xce->filepath); 
     1309                ZVAL_STRINGL(&literal->constant, xce->filepath, xce->filepath_len, !shallow_copy); 
     1310                TRACE("restored literal constant: %s", xce->filepath); 
     1311            } 
     1312#ifdef IS_UNICODE 
     1313            else if (Z_TYPE(literal->constant) == IS_UNICODE) { 
     1314                assert(xce->ufilepath); 
     1315                ZVAL_UNICODEL(&literal->constant, xce->ufilepath, xce->ufilepath_len, !shallow_copy); 
     1316            } 
     1317#endif 
     1318            else { 
     1319                assert(0); 
     1320            } 
     1321        } 
     1322        else if ((literalinfo & xcache_literal_is_dir)) { 
     1323            if (!shallow_copy) { 
     1324                efree(Z_STRVAL(literal->constant)); 
     1325            } 
     1326            if (Z_TYPE(literal->constant) == IS_STRING) { 
     1327                assert(xce->dirpath); 
     1328                TRACE("restored literal constant: %s", xce->dirpath); 
     1329                ZVAL_STRINGL(&literal->constant, xce->dirpath, xce->dirpath_len, !shallow_copy); 
     1330            } 
     1331#ifdef IS_UNICODE 
     1332            else if (Z_TYPE(literal->constant) == IS_UNICODE) { 
     1333                assert(!xce->udirpath); 
     1334                ZVAL_UNICODEL(&literal->constant, xce->udirpath, xce->udirpath_len, !shallow_copy); 
     1335            } 
     1336#endif 
     1337            else { 
     1338                assert(0); 
     1339            } 
     1340        } 
     1341    } 
    12621342#else 
    1263     int i; 
    1264 #endif 
    1265  
    1266 #ifdef ZEND_ENGINE_2_4 
    1267 #else 
    1268     for (i = 0; i < op_array_info->oplineinfo_cnt; i += 2) { 
    1269         int oplineno = op_array_info->oplineinfos[i]; 
    1270         int oplineinfo = op_array_info->oplineinfos[i + 1]; 
     1343    for (i = 0; i < op_array_info->oplineinfo_cnt; ++i) { 
     1344        int oplineno = op_array_info->oplineinfos[i].index; 
     1345        int oplineinfo = op_array_info->oplineinfos[i].info; 
    12711346        zend_op *opline = &op_array->opcodes[oplineno]; 
    12721347        if ((oplineinfo & xcache_op1_is_file)) { 
    12731348            assert(Z_OP_TYPE(opline->op1) == IS_CONST); 
    1274             if (copy) { 
     1349            if (!shallow_copy) { 
    12751350                efree(Z_STRVAL(Z_OP_CONSTANT(opline->op1))); 
    12761351            } 
    12771352            if (Z_TYPE(Z_OP_CONSTANT(opline->op1)) == IS_STRING) { 
    12781353                assert(xce->filepath); 
    1279                 ZVAL_STRINGL(&Z_OP_CONSTANT(opline->op1), xce->filepath, xce->filepath_len, copy); 
    1280                 TRACE("fixing op1 to %s", xce->filepath); 
     1354                ZVAL_STRINGL(&Z_OP_CONSTANT(opline->op1), xce->filepath, xce->filepath_len, !shallow_copy); 
     1355                TRACE("restored op1 constant: %s", xce->filepath); 
    12811356            } 
    12821357#ifdef IS_UNICODE 
    12831358            else if (Z_TYPE(Z_OP_CONSTANT(opline->op1)) == IS_UNICODE) { 
    12841359                assert(xce->ufilepath); 
    1285                 ZVAL_UNICODEL(&Z_OP_CONSTANT(opline->op1), xce->ufilepath, xce->ufilepath_len, copy); 
     1360                ZVAL_UNICODEL(&Z_OP_CONSTANT(opline->op1), xce->ufilepath, xce->ufilepath_len, !shallow_copy); 
    12861361            } 
    12871362#endif 
     
    12921367        else if ((oplineinfo & xcache_op1_is_dir)) { 
    12931368            assert(Z_OP_TYPE(opline->op1) == IS_CONST); 
    1294             if (copy) { 
     1369            if (!shallow_copy) { 
    12951370                efree(Z_STRVAL(Z_OP_CONSTANT(opline->op1))); 
    12961371            } 
    12971372            if (Z_TYPE(Z_OP_CONSTANT(opline->op1)) == IS_STRING) { 
    12981373                assert(xce->dirpath); 
    1299                 TRACE("fixing op1 to %s", xce->dirpath); 
    1300                 ZVAL_STRINGL(&Z_OP_CONSTANT(opline->op1), xce->dirpath, xce->dirpath_len, copy); 
     1374                TRACE("restored op1 constant: %s", xce->dirpath); 
     1375                ZVAL_STRINGL(&Z_OP_CONSTANT(opline->op1), xce->dirpath, xce->dirpath_len, !shallow_copy); 
    13011376            } 
    13021377#ifdef IS_UNICODE 
    13031378            else if (Z_TYPE(Z_OP_CONSTANT(opline->op1)) == IS_UNICODE) { 
    13041379                assert(!xce->udirpath); 
    1305                 ZVAL_UNICODEL(&Z_OP_CONSTANT(opline->op1), xce->udirpath, xce->udirpath_len, copy); 
     1380                ZVAL_UNICODEL(&Z_OP_CONSTANT(opline->op1), xce->udirpath, xce->udirpath_len, !shallow_copy); 
    13061381            } 
    13071382#endif 
     
    13131388        if ((oplineinfo & xcache_op2_is_file)) { 
    13141389            assert(Z_OP_TYPE(opline->op2) == IS_CONST); 
    1315             if (copy) { 
     1390            if (!shallow_copy) { 
    13161391                efree(Z_STRVAL(Z_OP_CONSTANT(opline->op2))); 
    13171392            } 
    13181393            if (Z_TYPE(Z_OP_CONSTANT(opline->op2)) == IS_STRING) { 
    13191394                assert(xce->filepath); 
    1320                 TRACE("fixing op2 to %s", xce->filepath); 
    1321                 ZVAL_STRINGL(&Z_OP_CONSTANT(opline->op2), xce->filepath, xce->filepath_len, copy); 
     1395                TRACE("restored op2 constant: %s", xce->filepath); 
     1396                ZVAL_STRINGL(&Z_OP_CONSTANT(opline->op2), xce->filepath, xce->filepath_len, !shallow_copy); 
    13221397            } 
    13231398#ifdef IS_UNICODE 
    13241399            else if (Z_TYPE(Z_OP_CONSTANT(opline->op2)) == IS_UNICODE) { 
    13251400                assert(xce->ufilepath); 
    1326                 ZVAL_UNICODEL(&Z_OP_CONSTANT(opline->op2), xce->ufilepath, xce->ufilepath_len, copy); 
     1401                ZVAL_UNICODEL(&Z_OP_CONSTANT(opline->op2), xce->ufilepath, xce->ufilepath_len, !shallow_copy); 
    13271402            } 
    13281403#endif 
     
    13331408        else if ((oplineinfo & xcache_op2_is_dir)) { 
    13341409            assert(Z_OP_TYPE(opline->op2) == IS_CONST); 
    1335             if (copy) { 
     1410            if (!shallow_copy) { 
    13361411                efree(Z_STRVAL(Z_OP_CONSTANT(opline->op2))); 
    13371412            } 
    13381413            if (Z_TYPE(Z_OP_CONSTANT(opline->op2)) == IS_STRING) { 
    13391414                assert(!xce->dirpath); 
    1340                 TRACE("fixing op2 to %s", xce->dirpath); 
    1341                 ZVAL_STRINGL(&Z_OP_CONSTANT(opline->op2), xce->dirpath, xce->dirpath_len, copy); 
     1415                TRACE("restored op2 constant: %s", xce->dirpath); 
     1416                ZVAL_STRINGL(&Z_OP_CONSTANT(opline->op2), xce->dirpath, xce->dirpath_len, !shallow_copy); 
    13421417            } 
    13431418#ifdef IS_UNICODE 
    13441419            else if (Z_TYPE(Z_OP_CONSTANT(opline->op2)) == IS_UNICODE) { 
    13451420                assert(!xce->udirpath); 
    1346                 ZVAL_UNICODEL(&Z_OP_CONSTANT(opline->op2), xce->udirpath, xce->udirpath_len, copy); 
     1421                ZVAL_UNICODEL(&Z_OP_CONSTANT(opline->op2), xce->udirpath, xce->udirpath_len, !shallow_copy); 
    13471422            } 
    13481423#endif 
Note: See TracChangeset for help on using the changeset viewer.