Fix performace regression due to missed peephole optimization

src/codegen-arm.cc

 // Copyright 2006-2008 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 930 matching lines @@
       masm->CallRuntime(Runtime::kStoreContextSlot, 3);
     }
     // Storing a variable must keep the (new) value on the expression
     // stack. This is necessary for compiling assignment expressions.
     masm->push(r0);
 
   } else {
     ASSERT(var()->mode() != Variable::DYNAMIC);
 
     Label exit;
+    bool skipped_write = false;
     if (init_state == CONST_INIT) {
       ASSERT(var()->mode() == Variable::CONST);
       // Only the first const initialization must be executed (the slot
       // still contains 'the hole' value). When the assignment is executed,
       // the code is identical to a normal store (see below).
       Comment cmnt(masm, "[ Init const");
       masm->ldr(r2, ArmCodeGenerator::SlotOperand(masm, scope, this, r2));
       masm->cmp(r2, Operand(Factory::the_hole_value()));
       masm->b(ne, &exit);
+      skipped_write = true;
     }
 
     // We must execute the store.
     // r2 may be loaded with context; used below in RecordWrite.
     // Storing a variable must keep the (new) value on the stack. This is
     // necessary for compiling assignment expressions.
     //
     // Note: We will reach here even with var()->mode() == Variable::CONST
     // because of const declarations which will initialize consts to 'the
     // hole' value and by doing so, end up calling this code.  r2 may be
     // loaded with context; used below in RecordWrite.
     masm->pop(r0);
     masm->str(r0, ArmCodeGenerator::SlotOperand(masm, scope, this, r2));
     masm->push(r0);
 
     if (type() == Slot::CONTEXT) {
       // Skip write barrier if the written value is a smi.
       masm->tst(r0, Operand(kSmiTagMask));
       masm->b(eq, &exit);
       // r2 is loaded with context when calling SlotOperand above.
       int offset = FixedArray::kHeaderSize + index() * kPointerSize;
       masm->mov(r3, Operand(offset));
       masm->RecordWrite(r2, r3, r1);
     }
-    masm->bind(&exit);
+    // If we did not jump over the assignment, we do not need to bind the
+    // exit label.  Doing so can defeat peephole optimization.
+    if (skipped_write) masm->bind(&exit);

[iposva, 2008/09/11 18:25:11]

Why do you introduce a separate variable for testing (init_state == CONST_INIT)?
In my opinion that is more confusing. Same for ia32.

   }
 }
 
 
 // ECMA-262, section 9.2, page 30: ToBoolean(). Convert the given
 // register to a boolean in the condition code register. The code
 // may jump to 'false_target' in case the register converts to 'false'.
 void ArmCodeGenerator::ToBoolean(Label* true_target,
                                  Label* false_target) {
   // Note: The generated code snippet does not change stack variables.
@@ skipping 3709 matching lines @@
                                      bool is_eval) {
   Handle<Code> code = ArmCodeGenerator::MakeCode(fun, script, is_eval);
   if (!code.is_null()) {
     Counters::total_compiled_code_size.Increment(code->instruction_size());
   }
   return code;
 }
 
 
 } }  // namespace v8::internal