Added support for assignments to global variables in the toplevel code...

src/ia32/fast-codegen-ia32.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 131 matching lines @@
   }
 }
 
 
 void FastCodeGenerator::VisitAssignment(Assignment* expr) {
   Comment cmnt(masm_, "[ Assignment");
   ASSERT(expr->op() == Token::ASSIGN || expr->op() == Token::INIT_VAR);
   Expression* rhs = expr->value();
   Visit(rhs);
 
-  // Left-hand side is always a (parameter or local) slot.
+  // Left-hand side can only be a global or a (parameter or local) slot.
   Variable* var = expr->target()->AsVariableProxy()->AsVariable();
-  ASSERT(var != NULL && var->slot() != NULL);
+  ASSERT(var != NULL);
+  ASSERT(var->is_global() || var->slot() != NULL);
 
   // Complete the assignment based on the location of the right-hand-side
   // value and the desired location of the assignment value.
   Location destination = expr->location();
   Location source = rhs->location();
   ASSERT(!destination.is_constant());
   ASSERT(!source.is_nowhere());
 
-  if (source.is_temporary()) {
+  if (var->is_global()) {
+    // Assignment to a global variable, use inline caching.  Right-hand-side
+    // value is passed in eax, variable name in ecx, and the global object
+    // on the stack.
+    if (source.is_temporary()) {
+      __ pop(eax);
+    } else {
+      ASSERT(source.is_constant());
+      ASSERT(rhs->AsLiteral() != NULL);
+      __ mov(eax, rhs->AsLiteral()->handle());
+    }
+    __ mov(ecx, var->name());
+    __ push(CodeGenerator::GlobalObject());
+    Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
+    __ call(ic, RelocInfo::CODE_TARGET);
+    // Overwrite the global object on the stack with the result if needed.
     if (destination.is_temporary()) {
-      // Case 'temp1 <- (var = temp0)'.  Preserve right-hand-side temporary
-      // on the stack.
-      __ mov(eax, Operand(esp, 0));
-      __ mov(Operand(ebp, SlotOffset(var->slot())), eax);
+      __ mov(Operand(esp, 0), eax);
     } else {
       ASSERT(destination.is_nowhere());
-      // Case 'var = temp'.  Discard right-hand-side temporary.
-      __ pop(Operand(ebp, SlotOffset(var->slot())));
+      __ pop(eax);

[fschneider, 2009/10/20 13:58:40]

We may avoid a memory access when discarding the result by just doing sth. like 

__ add(esp, 4)

here. However, it uses 3 bytes of space instead of 1.

[Kevin Millikin (Chromium), 2009/10/20 14:08:48]

Yes.  I didn't worry about it because:

Here we're not discarding the result, but the global object left on the stack by
the IC.  We should consider replacing the IC call with a runtime call anyway. 
We should consider making the IC drop the receiver (and take it in a register
anyway).

Ultimately, all real discarded values (of subexpressions) should not ever be
materialized in the first place.

     }
+
   } else {
-    ASSERT(source.is_constant());
-    ASSERT(rhs->AsLiteral() != NULL);
-    // Two cases: 'temp <- (var = constant)', or 'var = constant' with a
-    // discarded result.  Always perform the assignment.
-    __ mov(eax, rhs->AsLiteral()->handle());
-    __ mov(Operand(ebp, SlotOffset(var->slot())), eax);
-    if (destination.is_temporary()) {
-      // Case 'temp <- (var = constant)'.  Save result.
-      __ push(eax);
+    // Local or parameter assignment.
+    if (source.is_temporary()) {
+      if (destination.is_temporary()) {
+        // Case 'temp1 <- (var = temp0)'.  Preserve right-hand-side
+        // temporary on the stack.
+        __ mov(eax, Operand(esp, 0));
+        __ mov(Operand(ebp, SlotOffset(var->slot())), eax);
+      } else {
+        ASSERT(destination.is_nowhere());
+        // Case 'var = temp'.  Discard right-hand-side temporary.
+        __ pop(Operand(ebp, SlotOffset(var->slot())));
+      }
+    } else {
+      ASSERT(source.is_constant());
+      ASSERT(rhs->AsLiteral() != NULL);
+      // Two cases: 'temp <- (var = constant)', or 'var = constant' with a
+      // discarded result.  Always perform the assignment.
+      __ mov(eax, rhs->AsLiteral()->handle());
+      __ mov(Operand(ebp, SlotOffset(var->slot())), eax);
+      if (destination.is_temporary()) {
+        // Case 'temp <- (var = constant)'.  Save result.
+        __ push(eax);
+      }
     }
   }
 }
 
 
 } }  // namespace v8::internal