Generators return boxed values

src/ia32/full-codegen-ia32.cc

 // Copyright 2012 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 1882 matching lines @@
     case Yield::INITIAL:
     case Yield::SUSPEND: {
       VisitForStackValue(expr->generator_object());
       __ CallRuntime(Runtime::kSuspendJSGeneratorObject, 1);
       __ mov(context_register(),
              Operand(ebp, StandardFrameConstants::kContextOffset));
 
       Label resume;
       __ CompareRoot(result_register(), Heap::kTheHoleValueRootIndex);
       __ j(not_equal, &resume);
-      __ pop(result_register());
       if (expr->yield_kind() == Yield::SUSPEND) {
-        // TODO(wingo): Box into { value: VALUE, done: false }.
+        EmitReturnIteratorResult(false);
+      } else {
+        __ pop(result_register());
+        EmitReturnSequence();
       }
-      EmitReturnSequence();
 
       __ bind(&resume);
       context()->Plug(result_register());
       break;
     }
 
     case Yield::FINAL: {
       VisitForAccumulatorValue(expr->generator_object());
       __ mov(FieldOperand(result_register(),
                           JSGeneratorObject::kContinuationOffset),
              Immediate(Smi::FromInt(JSGeneratorObject::kGeneratorClosed)));
-      __ pop(result_register());
-      // TODO(wingo): Box into { value: VALUE, done: true }.
-
-      // Exit all nested statements.
-      NestedStatement* current = nesting_stack_;
-      int stack_depth = 0;
-      int context_length = 0;
-      while (current != NULL) {
-        current = current->Exit(&stack_depth, &context_length);
-      }
-      __ Drop(stack_depth);
-      EmitReturnSequence();
+      EmitReturnIteratorResult(true);
       break;
     }
 
     case Yield::DELEGATING:
       UNIMPLEMENTED();
   }
 }
 
 
 void FullCodeGenerator::EmitGeneratorResume(Expression *generator,
@@ skipping 85 matching lines @@
   // Throw error if we attempt to operate on a running generator.
   __ bind(&wrong_state);
   __ push(ebx);
   __ CallRuntime(Runtime::kThrowGeneratorStateError, 1);
 
   __ bind(&done);
   context()->Plug(result_register());
 }
 
 
+void FullCodeGenerator::EmitReturnIteratorResult(bool done) {
+  Label gc_required;
+  Label allocated;
+
+  STATIC_ASSERT(HeapObject::kMapOffset == 0);
+  STATIC_ASSERT(JSObject::kPropertiesOffset == kPointerSize);
+  STATIC_ASSERT(JSObject::kElementsOffset == 2 * kPointerSize);
+  STATIC_ASSERT(JSObject::kHeaderSize == 3 * kPointerSize);
+  STATIC_ASSERT(JSGeneratorObject::kResultValuePropertyIndex == 0);
+  STATIC_ASSERT(JSGeneratorObject::kResultDonePropertyIndex == 1);
+
+  const int size = 5 * kPointerSize;

[Michael Starzinger, 2013/05/06 11:22:32]

The size should be determined by
isolate()->native_context()->iterator_result_map()->instance_size() instead of a
hard-coded constant. Or at least we need to assert that this value matches out
expectation.

+  __ Allocate(size, eax, ecx, edx, &gc_required, TAG_OBJECT);
+
+  __ bind(&allocated);
+  // The object is now in eax.  Initialize its map, value, and done fields.
+  Handle<Map> map(isolate()->native_context()->iterator_result_map());
+  __ mov(ebx, map);
+  __ pop(ecx);
+  __ mov(edx,
+         done

[Michael Starzinger, 2013/05/06 11:22:32]

Use factory->ToBoolean(done) here.

+         ? isolate()->factory()->true_value()
+         : isolate()->factory()->false_value());
+  __ mov(FieldOperand(eax, 0 * kPointerSize), ebx);  // map

[Michael Starzinger, 2013/05/06 11:22:32]

Same comment as in bootstrapper.cc applies. Can we use the constant directly?

+  __ mov(FieldOperand(eax, 1 * kPointerSize),        // properties
+         isolate()->factory()->empty_fixed_array());
+  __ mov(FieldOperand(eax, 2 * kPointerSize),        // elements
+         isolate()->factory()->empty_fixed_array());
+  __ mov(FieldOperand(eax, 3 * kPointerSize), ecx);  // value
+  __ mov(FieldOperand(eax, 4 * kPointerSize), edx);  // done?
+
+  // Only the value field needs a write barrier, as the other values are in the
+  // root set.
+  __ RecordWriteField(eax, 3 * kPointerSize, ecx, edx, kDontSaveFPRegs);
+
+  if (done) {
+    // Exit all nested statements.
+    NestedStatement* current = nesting_stack_;
+    int stack_depth = 0;
+    int context_length = 0;
+    while (current != NULL) {
+      current = current->Exit(&stack_depth, &context_length);
+    }
+    __ Drop(stack_depth);
+  }
+
+  EmitReturnSequence();
+
+  __ bind(&gc_required);
+  __ Push(Smi::FromInt(size));
+  __ CallRuntime(Runtime::kAllocateInNewSpace, 1);
+  __ mov(context_register(),
+         Operand(ebp, StandardFrameConstants::kContextOffset));
+  __ jmp(&allocated);
+}
+
+
 void FullCodeGenerator::EmitNamedPropertyLoad(Property* prop) {
   SetSourcePosition(prop->position());
   Literal* key = prop->key()->AsLiteral();
   ASSERT(!key->handle()->IsSmi());
   __ mov(ecx, Immediate(key->handle()));
   Handle<Code> ic = isolate()->builtins()->LoadIC_Initialize();
   CallIC(ic, RelocInfo::CODE_TARGET, prop->PropertyFeedbackId());
 }
 
 
@@ skipping 2647 matching lines @@
   *stack_depth = 0;
   *context_length = 0;
   return previous_;
 }
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32