Update comment and add assert....

src/codegen-ia32.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 3857 matching lines @@
       // Push the result.
       frame->Push(eax);
       break;
     }
 
     case KEYED: {
       // TODO(1241834): Make sure that it is safe to ignore the
       // distinction between expressions in a typeof and not in a
       // typeof.
       Variable* var = expression_->AsVariableProxy()->AsVariable();
+      bool is_global = var != NULL;
+      ASSERT(!is_global || var->is_global());
       // Inline array load code if inside of a loop.  We do not know
       // the receiver map yet, so we initially generate the code with
       // a check against an invalid map.  In the inline cache code, we
       // patch the map check if appropriate.
       if (cgen_->loop_nesting() > 0) {
         Comment cmnt(masm, "[ Inlined array index load");
         DeferredReferenceGetKeyedValue* deferred =
-            new DeferredReferenceGetKeyedValue(cgen_, var != NULL);
+            new DeferredReferenceGetKeyedValue(cgen_, is_global);
         // Load receiver and check that it is not a smi (only needed
-        // if not contextual) and that it has the expected map.
+        // if this is not a load from the global context) and that it
+        // has the expected map.
         __ mov(edx, Operand(esp, kPointerSize));
-        if (var == NULL) {
+        if (!is_global) {
           __ test(edx, Immediate(kSmiTagMask));
           __ j(zero, deferred->enter(), not_taken);
         }
         // Initially, use an invalid map. The map is patched in the IC
         // initialization code.
         __ bind(deferred->patch_site());
         __ cmp(FieldOperand(edx, HeapObject::kMapOffset),
                Immediate(Factory::null_value()));
         __ j(not_equal, deferred->enter(), not_taken);
         // Load key and check that it is a smi.
@@ skipping 14 matching lines @@
         // Load and check that the result is not the hole.
         __ mov(eax,
                Operand(edx, eax, times_4, Array::kHeaderSize - kHeapObjectTag));
         __ cmp(Operand(eax), Immediate(Factory::the_hole_value()));
         __ j(equal, deferred->enter(), not_taken);
         __ IncrementCounter(&Counters::keyed_load_inline, 1);
         __ bind(deferred->exit());
       } else {
         Comment cmnt(masm, "[ Load from keyed Property");
         Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize));
-        if (var != NULL) {
-          ASSERT(var->is_global());
+        if (is_global) {
           __ call(ic, RelocInfo::CODE_TARGET_CONTEXT);
         } else {
           __ call(ic, RelocInfo::CODE_TARGET);
         }
         // Make sure that we do not have a test instruction after the
         // call.  A test instruction after the call is used to
         // indicate that we have generated an inline version of the
         // keyed load.  The explicit nop instruction is here because
         // the push that follows might be peep-hole optimized away.
         __ nop();
@@ skipping 1339 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal