Changeset 27255 in webkit for trunk/JavaScriptCore/kjs/nodes.cpp


Ignore:
Timestamp:
Oct 29, 2007, 10:36:24 PM (18 years ago)
Author:
oliver
Message:

Debranching remaining assignment nodes, and miscellaneous cleanup

Reviewed by Maciej.

Split read-modify code paths out of AssignBracketNode and AssignDotNode
Removed now unnecessary check for write-only assignment in ReadModifyLocalVarNode
and ReadModifyResolveNode evaluate methods

Leads to a 1% gain in SunSpider.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/kjs/nodes.cpp

    r27252 r27255  
    22072207    JSValue** slot = &variableObject->localStorage()[m_index].value;
    22082208
    2209     if (m_oper == OpEqual)
    2210         v = m_right->evaluate(exec);
    2211     else {
    2212         JSValue* v2 = m_right->evaluate(exec);
    2213         v = valueForReadModifyAssignment(exec, *slot, v2, m_oper);
    2214     }
     2209    ASSERT(m_oper != OpEqual);
     2210    JSValue* v2 = m_right->evaluate(exec);
     2211    v = valueForReadModifyAssignment(exec, *slot, v2, m_oper);
    22152212
    22162213    KJS_CHECKEXCEPTIONVALUE
    … …  
    22532250  } while (iter != end);
    22542251
    2255   if (m_oper != OpEqual)
    2256     return throwUndefinedVariableError(exec, m_ident);
     2252  ASSERT(m_oper != OpEqual);
     2253  return throwUndefinedVariableError(exec, m_ident);
    22572254
    22582255 found:
    22592256  JSValue *v;
    22602257
    2261   if (m_oper == OpEqual) {
    2262     v = m_right->evaluate(exec);
    2263   } else {
    2264     JSValue *v1 = slot.getValue(exec, base, m_ident);
    2265     KJS_CHECKEXCEPTIONVALUE
    2266     JSValue *v2 = m_right->evaluate(exec);
    2267     v = valueForReadModifyAssignment(exec, v1, v2, m_oper);
    2268   }
     2258 
     2259  ASSERT(m_oper != OpEqual);
     2260  JSValue *v1 = slot.getValue(exec, base, m_ident);
     2261  KJS_CHECKEXCEPTIONVALUE
     2262  JSValue *v2 = m_right->evaluate(exec);
     2263  v = valueForReadModifyAssignment(exec, v1, v2, m_oper);
    22692264
    22702265  KJS_CHECKEXCEPTIONVALUE
    … …  
    23022297}
    23032298
    2304 // ------------------------------ AssignDotNode -----------------------------------
     2299// ------------------------------ ReadModifyDotNode -----------------------------------
    23052300
    23062301void AssignDotNode::optimizeVariableAccess(FunctionBodyNode*, DeclarationStacks::NodeStack& nodeStack)
    … …  
    23162311  JSObject *base = baseValue->toObject(exec);
    23172312
     2313  JSValue *v = m_right->evaluate(exec);
     2314
     2315  KJS_CHECKEXCEPTIONVALUE
     2316
     2317  base->put(exec, m_ident, v);
     2318  return v;
     2319}
     2320
     2321void ReadModifyDotNode::optimizeVariableAccess(FunctionBodyNode*, DeclarationStacks::NodeStack& nodeStack)
     2322{
     2323    nodeStack.append(m_right.get());
     2324    nodeStack.append(m_base.get());
     2325}
     2326
     2327JSValue *ReadModifyDotNode::evaluate(ExecState *exec)
     2328{
     2329  JSValue *baseValue = m_base->evaluate(exec);
     2330  KJS_CHECKEXCEPTIONVALUE
     2331  JSObject *base = baseValue->toObject(exec);
     2332
    23182333  JSValue *v;
    23192334
    2320   if (m_oper == OpEqual) {
    2321     v = m_right->evaluate(exec);
    2322   } else {
     2335  ASSERT(m_oper != OpEqual);
     2336  PropertySlot slot;
     2337  JSValue *v1 = base->getPropertySlot(exec, m_ident, slot) ? slot.getValue(exec, base, m_ident) : jsUndefined();
     2338  KJS_CHECKEXCEPTIONVALUE
     2339  JSValue *v2 = m_right->evaluate(exec);
     2340  v = valueForReadModifyAssignment(exec, v1, v2, m_oper);
     2341
     2342  KJS_CHECKEXCEPTIONVALUE
     2343
     2344  base->put(exec, m_ident, v);
     2345  return v;
     2346}
     2347
     2348// ------------------------------ AssignErrorNode -----------------------------------
     2349
     2350JSValue* AssignErrorNode::evaluate(ExecState* exec)
     2351{
     2352    throwError(exec, ReferenceError, "Left side of assignment is not a reference.");
     2353    handleException(exec);
     2354    return jsUndefined();
     2355}
     2356
     2357// ------------------------------ AssignBracketNode -----------------------------------
     2358
     2359void AssignBracketNode::optimizeVariableAccess(FunctionBodyNode*, DeclarationStacks::NodeStack& nodeStack)
     2360{
     2361    nodeStack.append(m_right.get());
     2362    nodeStack.append(m_subscript.get());
     2363    nodeStack.append(m_base.get());
     2364}
     2365
     2366JSValue *AssignBracketNode::evaluate(ExecState *exec)
     2367{
     2368  JSValue *baseValue = m_base->evaluate(exec);
     2369  KJS_CHECKEXCEPTIONVALUE
     2370  JSValue *subscript = m_subscript->evaluate(exec);
     2371  KJS_CHECKEXCEPTIONVALUE
     2372
     2373  JSObject *base = baseValue->toObject(exec);
     2374
     2375  uint32_t propertyIndex;
     2376  if (subscript->getUInt32(propertyIndex)) {
     2377    JSValue *v = m_right->evaluate(exec);
     2378    KJS_CHECKEXCEPTIONVALUE
     2379
     2380    base->put(exec, propertyIndex, v);
     2381    return v;
     2382  }
     2383
     2384  Identifier propertyName(subscript->toString(exec));
     2385  JSValue *v = m_right->evaluate(exec);
     2386  KJS_CHECKEXCEPTIONVALUE
     2387
     2388  base->put(exec, propertyName, v);
     2389  return v;
     2390}
     2391void ReadModifyBracketNode::optimizeVariableAccess(FunctionBodyNode*, DeclarationStacks::NodeStack& nodeStack)
     2392{
     2393    nodeStack.append(m_right.get());
     2394    nodeStack.append(m_subscript.get());
     2395    nodeStack.append(m_base.get());
     2396}
     2397
     2398JSValue *ReadModifyBracketNode::evaluate(ExecState *exec)
     2399{
     2400  JSValue *baseValue = m_base->evaluate(exec);
     2401  KJS_CHECKEXCEPTIONVALUE
     2402  JSValue *subscript = m_subscript->evaluate(exec);
     2403  KJS_CHECKEXCEPTIONVALUE
     2404
     2405  JSObject *base = baseValue->toObject(exec);
     2406
     2407  uint32_t propertyIndex;
     2408  if (subscript->getUInt32(propertyIndex)) {
     2409    JSValue *v;
     2410    ASSERT(m_oper != OpEqual);
    23232411    PropertySlot slot;
    2324     JSValue *v1 = base->getPropertySlot(exec, m_ident, slot) ? slot.getValue(exec, base, m_ident) : jsUndefined();
     2412    JSValue *v1 = base->getPropertySlot(exec, propertyIndex, slot) ? slot.getValue(exec, base, propertyIndex) : jsUndefined();
    23252413    KJS_CHECKEXCEPTIONVALUE
    23262414    JSValue *v2 = m_right->evaluate(exec);
    23272415    v = valueForReadModifyAssignment(exec, v1, v2, m_oper);
    2328   }
    2329 
    2330   KJS_CHECKEXCEPTIONVALUE
    2331 
    2332   base->put(exec, m_ident, v);
    2333   return v;
    2334 }
    2335 
    2336 // ------------------------------ AssignErrorNode -----------------------------------
    2337 
    2338 JSValue* AssignErrorNode::evaluate(ExecState* exec)
    2339 {
    2340     throwError(exec, ReferenceError, "Left side of assignment is not a reference.");
    2341     handleException(exec);
    2342     return jsUndefined();
    2343 }
    2344 
    2345 // ------------------------------ AssignBracketNode -----------------------------------
    2346 
    2347 void AssignBracketNode::optimizeVariableAccess(FunctionBodyNode*, DeclarationStacks::NodeStack& nodeStack)
    2348 {
    2349     nodeStack.append(m_right.get());
    2350     nodeStack.append(m_subscript.get());
    2351     nodeStack.append(m_base.get());
    2352 }
    2353 
    2354 JSValue *AssignBracketNode::evaluate(ExecState *exec)
    2355 {
    2356   JSValue *baseValue = m_base->evaluate(exec);
    2357   KJS_CHECKEXCEPTIONVALUE
    2358   JSValue *subscript = m_subscript->evaluate(exec);
    2359   KJS_CHECKEXCEPTIONVALUE
    2360 
    2361   JSObject *base = baseValue->toObject(exec);
    2362 
    2363   uint32_t propertyIndex;
    2364   if (subscript->getUInt32(propertyIndex)) {
    2365     JSValue *v;
    2366     if (m_oper == OpEqual) {
    2367       v = m_right->evaluate(exec);
    2368     } else {
    2369       PropertySlot slot;
    2370       JSValue *v1 = base->getPropertySlot(exec, propertyIndex, slot) ? slot.getValue(exec, base, propertyIndex) : jsUndefined();
    2371       KJS_CHECKEXCEPTIONVALUE
    2372       JSValue *v2 = m_right->evaluate(exec);
    2373       v = valueForReadModifyAssignment(exec, v1, v2, m_oper);
    2374     }
    23752416
    23762417    KJS_CHECKEXCEPTIONVALUE
    … …  
    23832424  JSValue *v;
    23842425
    2385   if (m_oper == OpEqual) {
    2386     v = m_right->evaluate(exec);
    2387   } else {
    2388     PropertySlot slot;
    2389     JSValue *v1 = base->getPropertySlot(exec, propertyName, slot) ? slot.getValue(exec, base, propertyName) : jsUndefined();
    2390     KJS_CHECKEXCEPTIONVALUE
    2391     JSValue *v2 = m_right->evaluate(exec);
    2392     v = valueForReadModifyAssignment(exec, v1, v2, m_oper);
    2393   }
     2426  ASSERT(m_oper != OpEqual);
     2427  PropertySlot slot;
     2428  JSValue *v1 = base->getPropertySlot(exec, propertyName, slot) ? slot.getValue(exec, base, propertyName) : jsUndefined();
     2429  KJS_CHECKEXCEPTIONVALUE
     2430  JSValue *v2 = m_right->evaluate(exec);
     2431  v = valueForReadModifyAssignment(exec, v1, v2, m_oper);
    23942432
    23952433  KJS_CHECKEXCEPTIONVALUE
Note: See TracChangeset for help on using the changeset viewer.