Throw a TypeError when calling "next" method of a newly created generator with a value

src/arm/full-codegen-arm.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 1982 matching lines @@
       __ jmp(&suspend);
 
       __ bind(&continuation);
       __ jmp(&resume);
 
       __ bind(&suspend);
       VisitForAccumulatorValue(expr->generator_object());
       ASSERT(continuation.pos() > 0 && Smi::IsValid(continuation.pos()));
       __ mov(r1, Operand(Smi::FromInt(continuation.pos())));
       __ str(r1, FieldMemOperand(r0, JSGeneratorObject::kContinuationOffset));
+      if (expr->yield_kind() == Yield::INITIAL) {
+        __ str(r1,
+               FieldMemOperand(r0, JSGeneratorObject::kSuspendedStartOffset));
+      }
       __ str(cp, FieldMemOperand(r0, JSGeneratorObject::kContextOffset));
       __ mov(r1, cp);
       __ RecordWriteField(r0, JSGeneratorObject::kContextOffset, r1, r2,
                           kLRHasBeenSaved, kDontSaveFPRegs);
       __ add(r1, fp, Operand(StandardFrameConstants::kExpressionsOffset));
       __ cmp(sp, r1);
       __ b(eq, &post_runtime);
       __ push(r0);  // generator object
       __ CallRuntime(Runtime::kSuspendJSGeneratorObject, 1);
       __ ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
@@ skipping 106 matching lines @@
     JSGeneratorObject::ResumeMode resume_mode) {
   // The value stays in r0, and is ultimately read by the resumed generator, as
   // if the CallRuntime(Runtime::kSuspendJSGeneratorObject) returned it. Or it
   // is read to throw the value when the resumed generator is already closed.
   // r1 will hold the generator object until the activation has been resumed.
   VisitForStackValue(generator);
   VisitForAccumulatorValue(value);
   __ pop(r1);
 
   // Check generator state.
-  Label wrong_state, closed_state, done;
+  Label wrong_state, closed_state, suspended_start_state, resume_state, done;
   __ ldr(r3, FieldMemOperand(r1, JSGeneratorObject::kContinuationOffset));
   STATIC_ASSERT(JSGeneratorObject::kGeneratorExecuting < 0);
   STATIC_ASSERT(JSGeneratorObject::kGeneratorClosed == 0);
   __ cmp(r3, Operand(Smi::FromInt(0)));
   __ b(eq, &closed_state);
   __ b(lt, &wrong_state);
+  __ ldr(r2, FieldMemOperand(r1, JSGeneratorObject::kSuspendedStartOffset));
+  __ cmp(r3, r2);
+  __ b(eq, &suspended_start_state);
+
+  __ bind(&resume_state);
 
   // Load suspended function and context.
   __ ldr(cp, FieldMemOperand(r1, JSGeneratorObject::kContextOffset));
   __ ldr(r4, FieldMemOperand(r1, JSGeneratorObject::kFunctionOffset));
 
   // Load receiver and store as the first argument.
   __ ldr(r2, FieldMemOperand(r1, JSGeneratorObject::kReceiverOffset));
   __ push(r2);
 
   // Push holes for the rest of the arguments to the generator function.
@@ skipping 54 matching lines @@
   __ push(r2);
   __ b(&push_operand_holes);
   __ bind(&call_resume);
   ASSERT(!result_register().is(r1));
   __ Push(r1, result_register());
   __ Push(Smi::FromInt(resume_mode));
   __ CallRuntime(Runtime::kResumeJSGeneratorObject, 3);
   // Not reached: the runtime call returns elsewhere.
   __ stop("not-reached");
 
+  // Throw the provided value.
+  Label throw_provided_value;
+  __ bind(&throw_provided_value);
+  if (resume_mode != JSGeneratorObject::NEXT) {
+    __ push(r0);
+    __ CallRuntime(Runtime::kThrow, 1);
+    __ jmp(&done);
+  }
+
+  // Reach here when calling initial resume to a generator.
+  __ bind(&suspended_start_state);
+  if (resume_mode == JSGeneratorObject::NEXT) {
+    // When value is provided and it is not undefined, throw error.
+    __ CompareRoot(r0, Heap::kUndefinedValueRootIndex);
+    __ b(eq, &resume_state);
+    __ CallRuntime(Runtime::kThrowGeneratorStartError, 1);
+    __ jmp(&done);
+  } else {
+    // Make generator's state to "closed".
+    __ mov(r2, Operand(Smi::FromInt(JSGeneratorObject::kGeneratorClosed)));
+    __ str(r2, FieldMemOperand(r1, JSGeneratorObject::kContinuationOffset));
+    __ jmp(&throw_provided_value);
+  }
+
   // Reach here when generator is closed.
   __ bind(&closed_state);
   if (resume_mode == JSGeneratorObject::NEXT) {
     // Return completed iterator result when generator is closed.
     __ LoadRoot(r2, Heap::kUndefinedValueRootIndex);
     __ push(r2);
     // Pop value from top-of-stack slot; box result into result register.
     EmitCreateIteratorResult(true);
+    __ jmp(&done);
   } else {
-    // Throw the provided value.
-    __ push(r0);
-    __ CallRuntime(Runtime::kThrow, 1);
+    __ jmp(&throw_provided_value);
   }
-  __ jmp(&done);
 
   // Throw error if we attempt to operate on a running generator.
   __ bind(&wrong_state);
   __ push(r1);
   __ CallRuntime(Runtime::kThrowGeneratorStateError, 1);
 
   __ bind(&done);
   context()->Plug(result_register());
 }
 
@@ skipping 2675 matching lines @@
   ASSERT(Memory::uint32_at(interrupt_address_pointer) ==
          reinterpret_cast<uint32_t>(
              isolate->builtins()->OsrAfterStackCheck()->entry()));
   return OSR_AFTER_STACK_CHECK;
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM