Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 1 | // Copyright 2014 the V8 project authors. All rights reserved. |
| 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 5 | #include "src/runtime/runtime-utils.h" |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 6 | |
| 7 | #include "src/arguments.h" |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 8 | #include "src/factory.h" |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 9 | #include "src/frames-inl.h" |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 10 | #include "src/objects-inl.h" |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 11 | |
| 12 | namespace v8 { |
| 13 | namespace internal { |
| 14 | |
| 15 | RUNTIME_FUNCTION(Runtime_CreateJSGeneratorObject) { |
| 16 | HandleScope scope(isolate); |
| 17 | DCHECK(args.length() == 0); |
| 18 | |
| 19 | JavaScriptFrameIterator it(isolate); |
| 20 | JavaScriptFrame* frame = it.frame(); |
| 21 | Handle<JSFunction> function(frame->function()); |
| 22 | RUNTIME_ASSERT(function->shared()->is_generator()); |
| 23 | |
| 24 | Handle<JSGeneratorObject> generator; |
Ben Murdoch | 097c5b2 | 2016-05-18 11:27:45 +0100 | [diff] [blame] | 25 | DCHECK(!frame->IsConstructor()); |
| 26 | generator = isolate->factory()->NewJSGeneratorObject(function); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 27 | generator->set_function(*function); |
| 28 | generator->set_context(Context::cast(frame->context())); |
| 29 | generator->set_receiver(frame->receiver()); |
| 30 | generator->set_continuation(0); |
| 31 | generator->set_operand_stack(isolate->heap()->empty_fixed_array()); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 32 | |
| 33 | return *generator; |
| 34 | } |
| 35 | |
| 36 | |
| 37 | RUNTIME_FUNCTION(Runtime_SuspendJSGeneratorObject) { |
| 38 | HandleScope handle_scope(isolate); |
Ben Murdoch | 097c5b2 | 2016-05-18 11:27:45 +0100 | [diff] [blame] | 39 | DCHECK(args.length() == 1); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 40 | CONVERT_ARG_HANDLE_CHECKED(JSGeneratorObject, generator_object, 0); |
| 41 | |
| 42 | JavaScriptFrameIterator stack_iterator(isolate); |
| 43 | JavaScriptFrame* frame = stack_iterator.frame(); |
| 44 | RUNTIME_ASSERT(frame->function()->shared()->is_generator()); |
| 45 | DCHECK_EQ(frame->function(), generator_object->function()); |
Ben Murdoch | da12d29 | 2016-06-02 14:46:10 +0100 | [diff] [blame^] | 46 | DCHECK(frame->function()->shared()->is_compiled()); |
| 47 | DCHECK(!frame->function()->IsOptimized()); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 48 | |
| 49 | // The caller should have saved the context and continuation already. |
| 50 | DCHECK_EQ(generator_object->context(), Context::cast(frame->context())); |
| 51 | DCHECK_LT(0, generator_object->continuation()); |
| 52 | |
| 53 | // We expect there to be at least two values on the operand stack: the return |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 54 | // value of the yield expression, and the arguments to this runtime call. |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 55 | // Neither of those should be saved. |
| 56 | int operands_count = frame->ComputeOperandsCount(); |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 57 | DCHECK_GE(operands_count, 1 + args.length()); |
| 58 | operands_count -= 1 + args.length(); |
| 59 | |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 60 | if (operands_count == 0) { |
| 61 | // Although it's semantically harmless to call this function with an |
| 62 | // operands_count of zero, it is also unnecessary. |
| 63 | DCHECK_EQ(generator_object->operand_stack(), |
| 64 | isolate->heap()->empty_fixed_array()); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 65 | } else { |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 66 | Handle<FixedArray> operand_stack = |
| 67 | isolate->factory()->NewFixedArray(operands_count); |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 68 | frame->SaveOperandStack(*operand_stack); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 69 | generator_object->set_operand_stack(*operand_stack); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 70 | } |
| 71 | |
| 72 | return isolate->heap()->undefined_value(); |
| 73 | } |
| 74 | |
| 75 | |
| 76 | // Note that this function is the slow path for resuming generators. It is only |
| 77 | // called if the suspended activation had operands on the stack, stack handlers |
| 78 | // needing rewinding, or if the resume should throw an exception. The fast path |
| 79 | // is handled directly in FullCodeGenerator::EmitGeneratorResume(), which is |
Ben Murdoch | 097c5b2 | 2016-05-18 11:27:45 +0100 | [diff] [blame] | 80 | // inlined into GeneratorNext, GeneratorReturn, and GeneratorThrow. |
| 81 | // EmitGeneratorResume is called in any case, as it needs to reconstruct the |
| 82 | // stack frame and make space for arguments and operands. |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 83 | RUNTIME_FUNCTION(Runtime_ResumeJSGeneratorObject) { |
| 84 | SealHandleScope shs(isolate); |
| 85 | DCHECK(args.length() == 3); |
| 86 | CONVERT_ARG_CHECKED(JSGeneratorObject, generator_object, 0); |
| 87 | CONVERT_ARG_CHECKED(Object, value, 1); |
| 88 | CONVERT_SMI_ARG_CHECKED(resume_mode_int, 2); |
| 89 | JavaScriptFrameIterator stack_iterator(isolate); |
| 90 | JavaScriptFrame* frame = stack_iterator.frame(); |
| 91 | |
| 92 | DCHECK_EQ(frame->function(), generator_object->function()); |
Ben Murdoch | da12d29 | 2016-06-02 14:46:10 +0100 | [diff] [blame^] | 93 | DCHECK(frame->function()->shared()->is_compiled()); |
| 94 | DCHECK(!frame->function()->IsOptimized()); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 95 | |
| 96 | STATIC_ASSERT(JSGeneratorObject::kGeneratorExecuting < 0); |
| 97 | STATIC_ASSERT(JSGeneratorObject::kGeneratorClosed == 0); |
| 98 | |
Ben Murdoch | da12d29 | 2016-06-02 14:46:10 +0100 | [diff] [blame^] | 99 | Code* code = generator_object->function()->shared()->code(); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 100 | int offset = generator_object->continuation(); |
Ben Murdoch | da12d29 | 2016-06-02 14:46:10 +0100 | [diff] [blame^] | 101 | DCHECK_GT(offset, 0); |
| 102 | frame->set_pc(code->instruction_start() + offset); |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 103 | if (FLAG_enable_embedded_constant_pool) { |
Ben Murdoch | da12d29 | 2016-06-02 14:46:10 +0100 | [diff] [blame^] | 104 | frame->set_constant_pool(code->constant_pool()); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 105 | } |
| 106 | generator_object->set_continuation(JSGeneratorObject::kGeneratorExecuting); |
| 107 | |
| 108 | FixedArray* operand_stack = generator_object->operand_stack(); |
| 109 | int operands_count = operand_stack->length(); |
| 110 | if (operands_count != 0) { |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 111 | frame->RestoreOperandStack(operand_stack); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 112 | generator_object->set_operand_stack(isolate->heap()->empty_fixed_array()); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 113 | } |
| 114 | |
| 115 | JSGeneratorObject::ResumeMode resume_mode = |
| 116 | static_cast<JSGeneratorObject::ResumeMode>(resume_mode_int); |
| 117 | switch (resume_mode) { |
Ben Murdoch | 097c5b2 | 2016-05-18 11:27:45 +0100 | [diff] [blame] | 118 | // Note: this looks like NEXT and RETURN are the same but RETURN receives |
| 119 | // special treatment in the generator code (to which we return here). |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 120 | case JSGeneratorObject::NEXT: |
Ben Murdoch | 097c5b2 | 2016-05-18 11:27:45 +0100 | [diff] [blame] | 121 | case JSGeneratorObject::RETURN: |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 122 | return value; |
| 123 | case JSGeneratorObject::THROW: |
| 124 | return isolate->Throw(value); |
| 125 | } |
| 126 | |
| 127 | UNREACHABLE(); |
| 128 | return isolate->ThrowIllegalOperation(); |
| 129 | } |
| 130 | |
| 131 | |
| 132 | RUNTIME_FUNCTION(Runtime_GeneratorClose) { |
| 133 | HandleScope scope(isolate); |
| 134 | DCHECK(args.length() == 1); |
| 135 | CONVERT_ARG_HANDLE_CHECKED(JSGeneratorObject, generator, 0); |
| 136 | |
| 137 | generator->set_continuation(JSGeneratorObject::kGeneratorClosed); |
| 138 | |
| 139 | return isolate->heap()->undefined_value(); |
| 140 | } |
| 141 | |
| 142 | |
| 143 | // Returns function of generator activation. |
| 144 | RUNTIME_FUNCTION(Runtime_GeneratorGetFunction) { |
| 145 | HandleScope scope(isolate); |
| 146 | DCHECK(args.length() == 1); |
| 147 | CONVERT_ARG_HANDLE_CHECKED(JSGeneratorObject, generator, 0); |
| 148 | |
| 149 | return generator->function(); |
| 150 | } |
| 151 | |
| 152 | |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 153 | // Returns receiver of generator activation. |
| 154 | RUNTIME_FUNCTION(Runtime_GeneratorGetReceiver) { |
| 155 | HandleScope scope(isolate); |
| 156 | DCHECK(args.length() == 1); |
| 157 | CONVERT_ARG_HANDLE_CHECKED(JSGeneratorObject, generator, 0); |
| 158 | |
| 159 | return generator->receiver(); |
| 160 | } |
| 161 | |
| 162 | |
Ben Murdoch | 097c5b2 | 2016-05-18 11:27:45 +0100 | [diff] [blame] | 163 | // Returns input of generator activation. |
| 164 | RUNTIME_FUNCTION(Runtime_GeneratorGetInput) { |
| 165 | HandleScope scope(isolate); |
| 166 | DCHECK(args.length() == 1); |
| 167 | CONVERT_ARG_HANDLE_CHECKED(JSGeneratorObject, generator, 0); |
| 168 | |
| 169 | return generator->input(); |
| 170 | } |
| 171 | |
| 172 | |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 173 | // Returns generator continuation as a PC offset, or the magic -1 or 0 values. |
| 174 | RUNTIME_FUNCTION(Runtime_GeneratorGetContinuation) { |
| 175 | HandleScope scope(isolate); |
| 176 | DCHECK(args.length() == 1); |
| 177 | CONVERT_ARG_HANDLE_CHECKED(JSGeneratorObject, generator, 0); |
| 178 | |
| 179 | return Smi::FromInt(generator->continuation()); |
| 180 | } |
| 181 | |
| 182 | |
| 183 | RUNTIME_FUNCTION(Runtime_GeneratorGetSourcePosition) { |
| 184 | HandleScope scope(isolate); |
| 185 | DCHECK(args.length() == 1); |
| 186 | CONVERT_ARG_HANDLE_CHECKED(JSGeneratorObject, generator, 0); |
| 187 | |
| 188 | if (generator->is_suspended()) { |
| 189 | Handle<Code> code(generator->function()->code(), isolate); |
| 190 | int offset = generator->continuation(); |
Ben Murdoch | 097c5b2 | 2016-05-18 11:27:45 +0100 | [diff] [blame] | 191 | RUNTIME_ASSERT(0 <= offset && offset < code->instruction_size()); |
| 192 | return Smi::FromInt(code->SourcePosition(offset)); |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 193 | } |
| 194 | |
| 195 | return isolate->heap()->undefined_value(); |
| 196 | } |
| 197 | |
Ben Murdoch | da12d29 | 2016-06-02 14:46:10 +0100 | [diff] [blame^] | 198 | // Optimization for builtins calling any of the following three functions is |
| 199 | // disabled in js/generator.js and compiler.cc, hence they are unreachable. |
Ben Murdoch | 097c5b2 | 2016-05-18 11:27:45 +0100 | [diff] [blame] | 200 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 201 | RUNTIME_FUNCTION(Runtime_GeneratorNext) { |
Ben Murdoch | 097c5b2 | 2016-05-18 11:27:45 +0100 | [diff] [blame] | 202 | UNREACHABLE(); |
| 203 | return nullptr; |
| 204 | } |
| 205 | |
Ben Murdoch | 097c5b2 | 2016-05-18 11:27:45 +0100 | [diff] [blame] | 206 | RUNTIME_FUNCTION(Runtime_GeneratorReturn) { |
| 207 | UNREACHABLE(); |
| 208 | return nullptr; |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 209 | } |
| 210 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 211 | RUNTIME_FUNCTION(Runtime_GeneratorThrow) { |
Ben Murdoch | 097c5b2 | 2016-05-18 11:27:45 +0100 | [diff] [blame] | 212 | UNREACHABLE(); |
| 213 | return nullptr; |
Emily Bernier | d0a1eb7 | 2015-03-24 16:35:39 -0400 | [diff] [blame] | 214 | } |
Ben Murdoch | da12d29 | 2016-06-02 14:46:10 +0100 | [diff] [blame^] | 215 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 216 | } // namespace internal |
| 217 | } // namespace v8 |