Fix issue 541 and some refactoring of the top-level compiler.

src/fast-codegen.cc

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 621 matching lines @@
 
 void FastCodeGenerator::VisitLiteral(Literal* expr) {
   Comment cmnt(masm_, "[ Literal");
   Apply(expr->context(), expr);
 }
 
 
 void FastCodeGenerator::VisitAssignment(Assignment* expr) {
   Comment cmnt(masm_, "[ Assignment");
 
-  // Record source code position of the (possible) IC call.
-  SetSourcePosition(expr->position());
-
   // Left-hand side can only be a property, a global or a (parameter or local)
   // slot. Variables with rewrite to .arguments are treated as KEYED_PROPERTY.
   enum LhsKind { VARIABLE, NAMED_PROPERTY, KEYED_PROPERTY };
   LhsKind assign_type = VARIABLE;
   Property* prop = expr->target()->AsProperty();
   // In case of a property we use the uninitialized expression context
   // of the key to detect a named property.
   if (prop != NULL) {
     assign_type = (prop->key()->context() == Expression::kUninitialized)
         ? NAMED_PROPERTY
@@ skipping 20 matching lines @@
   // If we have a compound assignment: Get value of LHS expression and
   // store in on top of the stack.
   // Note: Relies on kValue context being 'stack'.
   if (expr->is_compound()) {
     switch (assign_type) {
       case VARIABLE:
         EmitVariableLoad(expr->target()->AsVariableProxy()->var(),
                          Expression::kValue);
         break;
       case NAMED_PROPERTY:
-        EmitNamedPropertyLoad(prop, Expression::kValue);
+        EmitNamedPropertyLoad(prop);
+        __ push(result_register());
         break;
       case KEYED_PROPERTY:
-        EmitKeyedPropertyLoad(prop, Expression::kValue);
+        EmitKeyedPropertyLoad(prop);
+        __ push(result_register());
         break;
     }
   }
 
   // Evaluate RHS expression.
   Expression* rhs = expr->value();
   ASSERT_EQ(Expression::kValue, rhs->context());
   Visit(rhs);
 
   // If we have a compount assignment: Apply operator.
   if (expr->is_compound()) {
     EmitCompoundAssignmentOp(expr->binary_op(), Expression::kValue);
   }
 
+  // Record source position before possible IC call.
+  SetSourcePosition(expr->position());
+
   // Store the value.
   switch (assign_type) {
     case VARIABLE:
       EmitVariableAssignment(expr->target()->AsVariableProxy()->var(),
                              expr->context());
       break;
     case NAMED_PROPERTY:
       EmitNamedPropertyAssignment(expr);
       break;
     case KEYED_PROPERTY:
@@ skipping 44 matching lines @@
   __ Drop(stack_depth);
   __ PopTryHandler();
   return 0;
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal