src/v8/src/full-codegen.cc

   1 // Copyright 2012 the V8 project authors. All rights reserved.
   2 // Redistribution and use in source and binary forms, with or without
   3 // modification, are permitted provided that the following conditions are
   4 // met:
   5 //
   6 //     * Redistributions of source code must retain the above copyright
   7 //       notice, this list of conditions and the following disclaimer.
   8 //     * Redistributions in binary form must reproduce the above
   9 //       copyright notice, this list of conditions and the following
  10 //       disclaimer in the documentation and/or other materials provided
  11 //       with the distribution.
  12 //     * Neither the name of Google Inc. nor the names of its
  13 //       contributors may be used to endorse or promote products derived
  14 //       from this software without specific prior written permission.
  15 //
  16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27
  28 #include "v8.h"
  29
  30 #include "codegen.h"
  31 #include "compiler.h"
  32 #include "debug.h"
  33 #include "full-codegen.h"
  34 #include "liveedit.h"
  35 #include "macro-assembler.h"
  36 #include "prettyprinter.h"
  37 #include "scopes.h"
  38 #include "scopeinfo.h"
  39 #include "snapshot.h"
  40 #include "stub-cache.h"
  41
  42 namespace v8 {
  43 namespace internal {
  44
  45 void BreakableStatementChecker::Check(Statement* stmt) {
  46   Visit(stmt);
  47 }
  48
  49
  50 void BreakableStatementChecker::Check(Expression* expr) {
  51   Visit(expr);
  52 }
  53
  54
  55 void BreakableStatementChecker::VisitVariableDeclaration(
  56     VariableDeclaration* decl) {
  57 }
  58
  59 void BreakableStatementChecker::VisitFunctionDeclaration(
  60     FunctionDeclaration* decl) {
  61 }
  62
  63 void BreakableStatementChecker::VisitModuleDeclaration(
  64     ModuleDeclaration* decl) {
  65 }
  66
  67 void BreakableStatementChecker::VisitImportDeclaration(
  68     ImportDeclaration* decl) {
  69 }
  70
  71 void BreakableStatementChecker::VisitExportDeclaration(
  72     ExportDeclaration* decl) {
  73 }
  74
  75
  76 void BreakableStatementChecker::VisitModuleLiteral(ModuleLiteral* module) {
  77 }
  78
  79
  80 void BreakableStatementChecker::VisitModuleVariable(ModuleVariable* module) {
  81 }
  82
  83
  84 void BreakableStatementChecker::VisitModulePath(ModulePath* module) {
  85 }
  86
  87
  88 void BreakableStatementChecker::VisitModuleUrl(ModuleUrl* module) {
  89 }
  90
  91
  92 void BreakableStatementChecker::VisitModuleStatement(ModuleStatement* stmt) {
  93 }
  94
  95
  96 void BreakableStatementChecker::VisitBlock(Block* stmt) {
  97 }
  98
  99
 100 void BreakableStatementChecker::VisitExpressionStatement(
 101     ExpressionStatement* stmt) {
 102   // Check if expression is breakable.
 103   Visit(stmt->expression());
 104 }
 105
 106
 107 void BreakableStatementChecker::VisitEmptyStatement(EmptyStatement* stmt) {
 108 }
 109
 110
 111 void BreakableStatementChecker::VisitIfStatement(IfStatement* stmt) {
 112   // If the condition is breakable the if statement is breakable.
 113   Visit(stmt->condition());
 114 }
 115
 116
 117 void BreakableStatementChecker::VisitContinueStatement(
 118     ContinueStatement* stmt) {
 119 }
 120
 121
 122 void BreakableStatementChecker::VisitBreakStatement(BreakStatement* stmt) {
 123 }
 124
 125
 126 void BreakableStatementChecker::VisitReturnStatement(ReturnStatement* stmt) {
 127   // Return is breakable if the expression is.
 128   Visit(stmt->expression());
 129 }
 130
 131
 132 void BreakableStatementChecker::VisitWithStatement(WithStatement* stmt) {
 133   Visit(stmt->expression());
 134 }
 135
 136
 137 void BreakableStatementChecker::VisitSwitchStatement(SwitchStatement* stmt) {
 138   // Switch statements breakable if the tag expression is.
 139   Visit(stmt->tag());
 140 }
 141
 142
 143 void BreakableStatementChecker::VisitDoWhileStatement(DoWhileStatement* stmt) {
 144   // Mark do while as breakable to avoid adding a break slot in front of it.
 145   is_breakable_ = true;
 146 }
 147
 148
 149 void BreakableStatementChecker::VisitWhileStatement(WhileStatement* stmt) {
 150   // Mark while statements breakable if the condition expression is.
 151   Visit(stmt->cond());
 152 }
 153
 154
 155 void BreakableStatementChecker::VisitForStatement(ForStatement* stmt) {
 156   // Mark for statements breakable if the condition expression is.
 157   if (stmt->cond() != NULL) {
 158     Visit(stmt->cond());
 159   }
 160 }
 161
 162
 163 void BreakableStatementChecker::VisitForInStatement(ForInStatement* stmt) {
 164   // Mark for in statements breakable if the enumerable expression is.
 165   Visit(stmt->enumerable());
 166 }
 167
 168
 169 void BreakableStatementChecker::VisitForOfStatement(ForOfStatement* stmt) {
 170   // For-of is breakable because of the next() call.
 171   is_breakable_ = true;
 172 }
 173
 174
 175 void BreakableStatementChecker::VisitTryCatchStatement(
 176     TryCatchStatement* stmt) {
 177   // Mark try catch as breakable to avoid adding a break slot in front of it.
 178   is_breakable_ = true;
 179 }
 180
 181
 182 void BreakableStatementChecker::VisitTryFinallyStatement(
 183     TryFinallyStatement* stmt) {
 184   // Mark try finally as breakable to avoid adding a break slot in front of it.
 185   is_breakable_ = true;
 186 }
 187
 188
 189 void BreakableStatementChecker::VisitDebuggerStatement(
 190     DebuggerStatement* stmt) {
 191   // The debugger statement is breakable.
 192   is_breakable_ = true;
 193 }
 194
 195
 196 void BreakableStatementChecker::VisitCaseClause(CaseClause* clause) {
 197 }
 198
 199
 200 void BreakableStatementChecker::VisitFunctionLiteral(FunctionLiteral* expr) {
 201 }
 202
 203
 204 void BreakableStatementChecker::VisitNativeFunctionLiteral(
 205     NativeFunctionLiteral* expr) {
 206 }
 207
 208
 209 void BreakableStatementChecker::VisitConditional(Conditional* expr) {
 210 }
 211
 212
 213 void BreakableStatementChecker::VisitVariableProxy(VariableProxy* expr) {
 214 }
 215
 216
 217 void BreakableStatementChecker::VisitLiteral(Literal* expr) {
 218 }
 219
 220
 221 void BreakableStatementChecker::VisitRegExpLiteral(RegExpLiteral* expr) {
 222 }
 223
 224
 225 void BreakableStatementChecker::VisitObjectLiteral(ObjectLiteral* expr) {
 226 }
 227
 228
 229 void BreakableStatementChecker::VisitArrayLiteral(ArrayLiteral* expr) {
 230 }
 231
 232
 233 void BreakableStatementChecker::VisitAssignment(Assignment* expr) {
 234   // If assigning to a property (including a global property) the assignment is
 235   // breakable.
 236   VariableProxy* proxy = expr->target()->AsVariableProxy();
 237   Property* prop = expr->target()->AsProperty();
 238   if (prop != NULL || (proxy != NULL && proxy->var()->IsUnallocated())) {
 239     is_breakable_ = true;
 240     return;
 241   }
 242
 243   // Otherwise the assignment is breakable if the assigned value is.
 244   Visit(expr->value());
 245 }
 246
 247
 248 void BreakableStatementChecker::VisitYield(Yield* expr) {
 249   // Yield is breakable if the expression is.
 250   Visit(expr->expression());
 251 }
 252
 253
 254 void BreakableStatementChecker::VisitThrow(Throw* expr) {
 255   // Throw is breakable if the expression is.
 256   Visit(expr->exception());
 257 }
 258
 259
 260 void BreakableStatementChecker::VisitProperty(Property* expr) {
 261   // Property load is breakable.
 262   is_breakable_ = true;
 263 }
 264
 265
 266 void BreakableStatementChecker::VisitCall(Call* expr) {
 267   // Function calls both through IC and call stub are breakable.
 268   is_breakable_ = true;
 269 }
 270
 271
 272 void BreakableStatementChecker::VisitCallNew(CallNew* expr) {
 273   // Function calls through new are breakable.
 274   is_breakable_ = true;
 275 }
 276
 277
 278 void BreakableStatementChecker::VisitCallRuntime(CallRuntime* expr) {
 279 }
 280
 281
 282 void BreakableStatementChecker::VisitUnaryOperation(UnaryOperation* expr) {
 283   Visit(expr->expression());
 284 }
 285
 286
 287 void BreakableStatementChecker::VisitCountOperation(CountOperation* expr) {
 288   Visit(expr->expression());
 289 }
 290
 291
 292 void BreakableStatementChecker::VisitBinaryOperation(BinaryOperation* expr) {
 293   Visit(expr->left());
 294   if (expr->op() != Token::AND &&
 295       expr->op() != Token::OR) {
 296     Visit(expr->right());
 297   }
 298 }
 299
 300
 301 void BreakableStatementChecker::VisitCompareOperation(CompareOperation* expr) {
 302   Visit(expr->left());
 303   Visit(expr->right());
 304 }
 305
 306
 307 void BreakableStatementChecker::VisitThisFunction(ThisFunction* expr) {
 308 }
 309
 310
 311 #define __ ACCESS_MASM(masm())
 312
 313 bool FullCodeGenerator::MakeCode(CompilationInfo* info) {
 314   Isolate* isolate = info->isolate();
 315
 316   Logger::TimerEventScope timer(
 317       isolate, Logger::TimerEventScope::v8_compile_full_code);
 318
 319   Handle<Script> script = info->script();
 320   if (!script->IsUndefined() && !script->source()->IsUndefined()) {
 321     int len = String::cast(script->source())->length();
 322     isolate->counters()->total_full_codegen_source_size()->Increment(len);
 323   }
 324   CodeGenerator::MakeCodePrologue(info, "full");
 325   const int kInitialBufferSize = 4 * KB;
 326   MacroAssembler masm(info->isolate(), NULL, kInitialBufferSize);
 327 #ifdef ENABLE_GDB_JIT_INTERFACE
 328   masm.positions_recorder()->StartGDBJITLineInfoRecording();
 329 #endif
 330   LOG_CODE_EVENT(isolate,
 331                  CodeStartLinePosInfoRecordEvent(masm.positions_recorder()));
 332
 333   FullCodeGenerator cgen(&masm, info);
 334   cgen.Generate();
 335   if (cgen.HasStackOverflow()) {
 336     ASSERT(!isolate->has_pending_exception());
 337     return false;
 338   }
 339   unsigned table_offset = cgen.EmitBackEdgeTable();
 340
 341   Code::Flags flags = Code::ComputeFlags(Code::FUNCTION);
 342   Handle<Code> code = CodeGenerator::MakeCodeEpilogue(&masm, flags, info);
 343   code->set_optimizable(info->IsOptimizable() &&
 344                         !info->function()->dont_optimize() &&
 345                         info->function()->scope()->AllowsLazyCompilation());
 346   cgen.PopulateDeoptimizationData(code);
 347   cgen.PopulateTypeFeedbackInfo(code);
 348   cgen.PopulateTypeFeedbackCells(code);
 349   code->set_has_deoptimization_support(info->HasDeoptimizationSupport());
 350   code->set_handler_table(*cgen.handler_table());
 351 #ifdef ENABLE_DEBUGGER_SUPPORT
 352   code->set_compiled_optimizable(info->IsOptimizable());
 353 #endif  // ENABLE_DEBUGGER_SUPPORT
 354   code->set_allow_osr_at_loop_nesting_level(0);
 355   code->set_profiler_ticks(0);
 356   code->set_back_edge_table_offset(table_offset);
 357   code->set_back_edges_patched_for_osr(false);
 358   CodeGenerator::PrintCode(code, info);
 359   info->SetCode(code);
 360 #ifdef ENABLE_GDB_JIT_INTERFACE
 361   if (FLAG_gdbjit) {
 362     GDBJITLineInfo* lineinfo =
 363         masm.positions_recorder()->DetachGDBJITLineInfo();
 364     GDBJIT(RegisterDetailedLineInfo(*code, lineinfo));
 365   }
 366 #endif
 367   void* line_info = masm.positions_recorder()->DetachJITHandlerData();
 368   LOG_CODE_EVENT(isolate, CodeEndLinePosInfoRecordEvent(*code, line_info));
 369   return true;
 370 }
 371
 372
 373 unsigned FullCodeGenerator::EmitBackEdgeTable() {
 374   // The back edge table consists of a length (in number of entries)
 375   // field, and then a sequence of entries.  Each entry is a pair of AST id
 376   // and code-relative pc offset.
 377   masm()->Align(kIntSize);
 378   unsigned offset = masm()->pc_offset();
 379   unsigned length = back_edges_.length();
 380   __ dd(length);
 381   for (unsigned i = 0; i < length; ++i) {
 382     __ dd(back_edges_[i].id.ToInt());
 383     __ dd(back_edges_[i].pc);
 384     __ dd(back_edges_[i].loop_depth);
 385   }
 386   return offset;
 387 }
 388
 389
 390 void FullCodeGenerator::PopulateDeoptimizationData(Handle<Code> code) {
 391   // Fill in the deoptimization information.
 392   ASSERT(info_->HasDeoptimizationSupport() || bailout_entries_.is_empty());
 393   if (!info_->HasDeoptimizationSupport()) return;
 394   int length = bailout_entries_.length();
 395   Handle<DeoptimizationOutputData> data = isolate()->factory()->
 396       NewDeoptimizationOutputData(length, TENURED);
 397   for (int i = 0; i < length; i++) {
 398     data->SetAstId(i, bailout_entries_[i].id);
 399     data->SetPcAndState(i, Smi::FromInt(bailout_entries_[i].pc_and_state));
 400   }
 401   code->set_deoptimization_data(*data);
 402 }
 403
 404
 405 void FullCodeGenerator::PopulateTypeFeedbackInfo(Handle<Code> code) {
 406   Handle<TypeFeedbackInfo> info = isolate()->factory()->NewTypeFeedbackInfo();
 407   info->set_ic_total_count(ic_total_count_);
 408   ASSERT(!isolate()->heap()->InNewSpace(*info));
 409   code->set_type_feedback_info(*info);
 410 }
 411
 412
 413 void FullCodeGenerator::Initialize() {
 414   // The generation of debug code must match between the snapshot code and the
 415   // code that is generated later.  This is assumed by the debugger when it is
 416   // calculating PC offsets after generating a debug version of code.  Therefore
 417   // we disable the production of debug code in the full compiler if we are
 418   // either generating a snapshot or we booted from a snapshot.
 419   generate_debug_code_ = FLAG_debug_code &&
 420                          !Serializer::enabled() &&
 421                          !Snapshot::HaveASnapshotToStartFrom();
 422   masm_->set_emit_debug_code(generate_debug_code_);
 423   masm_->set_predictable_code_size(true);
 424   InitializeAstVisitor(info_->zone());
 425 }
 426
 427
 428 void FullCodeGenerator::PopulateTypeFeedbackCells(Handle<Code> code) {
 429   if (type_feedback_cells_.is_empty()) return;
 430   int length = type_feedback_cells_.length();
 431   int array_size = TypeFeedbackCells::LengthOfFixedArray(length);
 432   Handle<TypeFeedbackCells> cache = Handle<TypeFeedbackCells>::cast(
 433       isolate()->factory()->NewFixedArray(array_size, TENURED));
 434   for (int i = 0; i < length; i++) {
 435     cache->SetAstId(i, type_feedback_cells_[i].ast_id);
 436     cache->SetCell(i, *type_feedback_cells_[i].cell);
 437   }
 438   TypeFeedbackInfo::cast(code->type_feedback_info())->set_type_feedback_cells(
 439       *cache);
 440 }
 441
 442
 443 void FullCodeGenerator::PrepareForBailout(Expression* node, State state) {
 444   PrepareForBailoutForId(node->id(), state);
 445 }
 446
 447
 448 void FullCodeGenerator::CallLoadIC(ContextualMode mode, TypeFeedbackId id) {
 449   Handle<Code> ic = LoadIC::initialize_stub(isolate(), mode);
 450   CallIC(ic, mode, id);
 451 }
 452
 453
 454 void FullCodeGenerator::CallStoreIC(ContextualMode mode, TypeFeedbackId id) {
 455   Handle<Code> ic = StoreIC::initialize_stub(isolate(), strict_mode());
 456   CallIC(ic, mode, id);
 457 }
 458
 459
 460 void FullCodeGenerator::RecordJSReturnSite(Call* call) {
 461   // We record the offset of the function return so we can rebuild the frame
 462   // if the function was inlined, i.e., this is the return address in the
 463   // inlined function's frame.
 464   //
 465   // The state is ignored.  We defensively set it to TOS_REG, which is the
 466   // real state of the unoptimized code at the return site.
 467   PrepareForBailoutForId(call->ReturnId(), TOS_REG);
 468 #ifdef DEBUG
 469   // In debug builds, mark the return so we can verify that this function
 470   // was called.
 471   ASSERT(!call->return_is_recorded_);
 472   call->return_is_recorded_ = true;
 473 #endif
 474 }
 475
 476
 477 void FullCodeGenerator::PrepareForBailoutForId(BailoutId id, State state) {
 478   // There's no need to prepare this code for bailouts from already optimized
 479   // code or code that can't be optimized.
 480   if (!info_->HasDeoptimizationSupport()) return;
 481   unsigned pc_and_state =
 482       StateField::encode(state) | PcField::encode(masm_->pc_offset());
 483   ASSERT(Smi::IsValid(pc_and_state));
 484   BailoutEntry entry = { id, pc_and_state };
 485   ASSERT(!prepared_bailout_ids_.Contains(id.ToInt()));
 486   prepared_bailout_ids_.Add(id.ToInt(), zone());
 487   bailout_entries_.Add(entry, zone());
 488 }
 489
 490
 491 void FullCodeGenerator::RecordTypeFeedbackCell(
 492     TypeFeedbackId id, Handle<Cell> cell) {
 493   TypeFeedbackCellEntry entry = { id, cell };
 494   type_feedback_cells_.Add(entry, zone());
 495 }
 496
 497
 498 void FullCodeGenerator::RecordBackEdge(BailoutId ast_id) {
 499   // The pc offset does not need to be encoded and packed together with a state.
 500   ASSERT(masm_->pc_offset() > 0);
 501   ASSERT(loop_depth() > 0);
 502   uint8_t depth = Min(loop_depth(), Code::kMaxLoopNestingMarker);
 503   BackEdgeEntry entry =
 504       { ast_id, static_cast<unsigned>(masm_->pc_offset()), depth };
 505   back_edges_.Add(entry, zone());
 506 }
 507
 508
 509 bool FullCodeGenerator::ShouldInlineSmiCase(Token::Value op) {
 510   // Inline smi case inside loops, but not division and modulo which
 511   // are too complicated and take up too much space.
 512   if (op == Token::DIV ||op == Token::MOD) return false;
 513   if (FLAG_always_inline_smi_code) return true;
 514   return loop_depth_ > 0;
 515 }
 516
 517
 518 void FullCodeGenerator::EffectContext::Plug(Register reg) const {
 519 }
 520
 521
 522 void FullCodeGenerator::AccumulatorValueContext::Plug(Register reg) const {
 523   __ Move(result_register(), reg);
 524 }
 525
 526
 527 void FullCodeGenerator::StackValueContext::Plug(Register reg) const {
 528   __ Push(reg);
 529 }
 530
 531
 532 void FullCodeGenerator::TestContext::Plug(Register reg) const {
 533   // For simplicity we always test the accumulator register.
 534   __ Move(result_register(), reg);
 535   codegen()->PrepareForBailoutBeforeSplit(condition(), false, NULL, NULL);
 536   codegen()->DoTest(this);
 537 }
 538
 539
 540 void FullCodeGenerator::EffectContext::PlugTOS() const {
 541   __ Drop(1);
 542 }
 543
 544
 545 void FullCodeGenerator::AccumulatorValueContext::PlugTOS() const {
 546   __ Pop(result_register());
 547 }
 548
 549
 550 void FullCodeGenerator::StackValueContext::PlugTOS() const {
 551 }
 552
 553
 554 void FullCodeGenerator::TestContext::PlugTOS() const {
 555   // For simplicity we always test the accumulator register.
 556   __ Pop(result_register());
 557   codegen()->PrepareForBailoutBeforeSplit(condition(), false, NULL, NULL);
 558   codegen()->DoTest(this);
 559 }
 560
 561
 562 void FullCodeGenerator::EffectContext::PrepareTest(
 563     Label* materialize_true,
 564     Label* materialize_false,
 565     Label** if_true,
 566     Label** if_false,
 567     Label** fall_through) const {
 568   // In an effect context, the true and the false case branch to the
 569   // same label.
 570   *if_true = *if_false = *fall_through = materialize_true;
 571 }
 572
 573
 574 void FullCodeGenerator::AccumulatorValueContext::PrepareTest(
 575     Label* materialize_true,
 576     Label* materialize_false,
 577     Label** if_true,
 578     Label** if_false,
 579     Label** fall_through) const {
 580   *if_true = *fall_through = materialize_true;
 581   *if_false = materialize_false;
 582 }
 583
 584
 585 void FullCodeGenerator::StackValueContext::PrepareTest(
 586     Label* materialize_true,
 587     Label* materialize_false,
 588     Label** if_true,
 589     Label** if_false,
 590     Label** fall_through) const {
 591   *if_true = *fall_through = materialize_true;
 592   *if_false = materialize_false;
 593 }
 594
 595
 596 void FullCodeGenerator::TestContext::PrepareTest(
 597     Label* materialize_true,
 598     Label* materialize_false,
 599     Label** if_true,
 600     Label** if_false,
 601     Label** fall_through) const {
 602   *if_true = true_label_;
 603   *if_false = false_label_;
 604   *fall_through = fall_through_;
 605 }
 606
 607
 608 void FullCodeGenerator::DoTest(const TestContext* context) {
 609   DoTest(context->condition(),
 610          context->true_label(),
 611          context->false_label(),
 612          context->fall_through());
 613 }
 614
 615
 616 void FullCodeGenerator::AllocateModules(ZoneList<Declaration*>* declarations) {
 617   ASSERT(scope_->is_global_scope());
 618
 619   for (int i = 0; i < declarations->length(); i++) {
 620     ModuleDeclaration* declaration = declarations->at(i)->AsModuleDeclaration();
 621     if (declaration != NULL) {
 622       ModuleLiteral* module = declaration->module()->AsModuleLiteral();
 623       if (module != NULL) {
 624         Comment cmnt(masm_, "[ Link nested modules");
 625         Scope* scope = module->body()->scope();
 626         Interface* interface = scope->interface();
 627         ASSERT(interface->IsModule() && interface->IsFrozen());
 628
 629         interface->Allocate(scope->module_var()->index());
 630
 631         // Set up module context.
 632         ASSERT(scope->interface()->Index() >= 0);
 633         __ Push(Smi::FromInt(scope->interface()->Index()));
 634         __ Push(scope->GetScopeInfo());
 635         __ CallRuntime(Runtime::kPushModuleContext, 2);
 636         StoreToFrameField(StandardFrameConstants::kContextOffset,
 637                           context_register());
 638
 639         AllocateModules(scope->declarations());
 640
 641         // Pop module context.
 642         LoadContextField(context_register(), Context::PREVIOUS_INDEX);
 643         // Update local stack frame context field.
 644         StoreToFrameField(StandardFrameConstants::kContextOffset,
 645                           context_register());
 646       }
 647     }
 648   }
 649 }
 650
 651
 652 // Modules have their own local scope, represented by their own context.
 653 // Module instance objects have an accessor for every export that forwards
 654 // access to the respective slot from the module's context. (Exports that are
 655 // modules themselves, however, are simple data properties.)
 656 //
 657 // All modules have a _hosting_ scope/context, which (currently) is the
 658 // (innermost) enclosing global scope. To deal with recursion, nested modules
 659 // are hosted by the same scope as global ones.
 660 //
 661 // For every (global or nested) module literal, the hosting context has an
 662 // internal slot that points directly to the respective module context. This
 663 // enables quick access to (statically resolved) module members by 2-dimensional
 664 // access through the hosting context. For example,
 665 //
 666 //   module A {
 667 //     let x;
 668 //     module B { let y; }
 669 //   }
 670 //   module C { let z; }
 671 //
 672 // allocates contexts as follows:
 673 //
 674 // [header| .A | .B | .C | A | C ]  (global)
 675 //           |    |    |
 676 //           |    |    +-- [header| z ]  (module)
 677 //           |    |
 678 //           |    +------- [header| y ]  (module)
 679 //           |
 680 //           +------------ [header| x | B ]  (module)
 681 //
 682 // Here, .A, .B, .C are the internal slots pointing to the hosted module
 683 // contexts, whereas A, B, C hold the actual instance objects (note that every
 684 // module context also points to the respective instance object through its
 685 // extension slot in the header).
 686 //
 687 // To deal with arbitrary recursion and aliases between modules,
 688 // they are created and initialized in several stages. Each stage applies to
 689 // all modules in the hosting global scope, including nested ones.
 690 //
 691 // 1. Allocate: for each module _literal_, allocate the module contexts and
 692 //    respective instance object and wire them up. This happens in the
 693 //    PushModuleContext runtime function, as generated by AllocateModules
 694 //    (invoked by VisitDeclarations in the hosting scope).
 695 //
 696 // 2. Bind: for each module _declaration_ (i.e. literals as well as aliases),
 697 //    assign the respective instance object to respective local variables. This
 698 //    happens in VisitModuleDeclaration, and uses the instance objects created
 699 //    in the previous stage.
 700 //    For each module _literal_, this phase also constructs a module descriptor
 701 //    for the next stage. This happens in VisitModuleLiteral.
 702 //
 703 // 3. Populate: invoke the DeclareModules runtime function to populate each
 704 //    _instance_ object with accessors for it exports. This is generated by
 705 //    DeclareModules (invoked by VisitDeclarations in the hosting scope again),
 706 //    and uses the descriptors generated in the previous stage.
 707 //
 708 // 4. Initialize: execute the module bodies (and other code) in sequence. This
 709 //    happens by the separate statements generated for module bodies. To reenter
 710 //    the module scopes properly, the parser inserted ModuleStatements.
 711
 712 void FullCodeGenerator::VisitDeclarations(
 713     ZoneList<Declaration*>* declarations) {
 714   Handle<FixedArray> saved_modules = modules_;
 715   int saved_module_index = module_index_;
 716   ZoneList<Handle<Object> >* saved_globals = globals_;
 717   ZoneList<Handle<Object> > inner_globals(10, zone());
 718   globals_ = &inner_globals;
 719
 720   if (scope_->num_modules() != 0) {
 721     // This is a scope hosting modules. Allocate a descriptor array to pass
 722     // to the runtime for initialization.
 723     Comment cmnt(masm_, "[ Allocate modules");
 724     ASSERT(scope_->is_global_scope());
 725     modules_ =
 726         isolate()->factory()->NewFixedArray(scope_->num_modules(), TENURED);
 727     module_index_ = 0;
 728
 729     // Generate code for allocating all modules, including nested ones.
 730     // The allocated contexts are stored in internal variables in this scope.
 731     AllocateModules(declarations);
 732   }
 733
 734   AstVisitor::VisitDeclarations(declarations);
 735
 736   if (scope_->num_modules() != 0) {
 737     // Initialize modules from descriptor array.
 738     ASSERT(module_index_ == modules_->length());
 739     DeclareModules(modules_);
 740     modules_ = saved_modules;
 741     module_index_ = saved_module_index;
 742   }
 743
 744   if (!globals_->is_empty()) {
 745     // Invoke the platform-dependent code generator to do the actual
 746     // declaration of the global functions and variables.
 747     Handle<FixedArray> array =
 748        isolate()->factory()->NewFixedArray(globals_->length(), TENURED);
 749     for (int i = 0; i < globals_->length(); ++i)
 750       array->set(i, *globals_->at(i));
 751     DeclareGlobals(array);
 752   }
 753
 754   globals_ = saved_globals;
 755 }
 756
 757
 758 void FullCodeGenerator::VisitModuleLiteral(ModuleLiteral* module) {
 759   Block* block = module->body();
 760   Scope* saved_scope = scope();
 761   scope_ = block->scope();
 762   Interface* interface = scope_->interface();
 763
 764   Comment cmnt(masm_, "[ ModuleLiteral");
 765   SetStatementPosition(block);
 766
 767   ASSERT(!modules_.is_null());
 768   ASSERT(module_index_ < modules_->length());
 769   int index = module_index_++;
 770
 771   // Set up module context.
 772   ASSERT(interface->Index() >= 0);
 773   __ Push(Smi::FromInt(interface->Index()));
 774   __ Push(Smi::FromInt(0));
 775   __ CallRuntime(Runtime::kPushModuleContext, 2);
 776   StoreToFrameField(StandardFrameConstants::kContextOffset, context_register());
 777
 778   {
 779     Comment cmnt(masm_, "[ Declarations");
 780     VisitDeclarations(scope_->declarations());
 781   }
 782
 783   // Populate the module description.
 784   Handle<ModuleInfo> description =
 785       ModuleInfo::Create(isolate(), interface, scope_);
 786   modules_->set(index, *description);
 787
 788   scope_ = saved_scope;
 789   // Pop module context.
 790   LoadContextField(context_register(), Context::PREVIOUS_INDEX);
 791   // Update local stack frame context field.
 792   StoreToFrameField(StandardFrameConstants::kContextOffset, context_register());
 793 }
 794
 795
 796 void FullCodeGenerator::VisitModuleVariable(ModuleVariable* module) {
 797   // Nothing to do.
 798   // The instance object is resolved statically through the module's interface.
 799 }
 800
 801
 802 void FullCodeGenerator::VisitModulePath(ModulePath* module) {
 803   // Nothing to do.
 804   // The instance object is resolved statically through the module's interface.
 805 }
 806
 807
 808 void FullCodeGenerator::VisitModuleUrl(ModuleUrl* module) {
 809   // TODO(rossberg): dummy allocation for now.
 810   Scope* scope = module->body()->scope();
 811   Interface* interface = scope_->interface();
 812
 813   ASSERT(interface->IsModule() && interface->IsFrozen());
 814   ASSERT(!modules_.is_null());
 815   ASSERT(module_index_ < modules_->length());
 816   interface->Allocate(scope->module_var()->index());
 817   int index = module_index_++;
 818
 819   Handle<ModuleInfo> description =
 820       ModuleInfo::Create(isolate(), interface, scope_);
 821   modules_->set(index, *description);
 822 }
 823
 824
 825 int FullCodeGenerator::DeclareGlobalsFlags() {
 826   ASSERT(DeclareGlobalsLanguageMode::is_valid(language_mode()));
 827   return DeclareGlobalsEvalFlag::encode(is_eval()) |
 828       DeclareGlobalsNativeFlag::encode(is_native()) |
 829       DeclareGlobalsLanguageMode::encode(language_mode());
 830 }
 831
 832
 833 void FullCodeGenerator::SetFunctionPosition(FunctionLiteral* fun) {
 834   CodeGenerator::RecordPositions(masm_, fun->start_position());
 835 }
 836
 837
 838 void FullCodeGenerator::SetReturnPosition(FunctionLiteral* fun) {
 839   CodeGenerator::RecordPositions(masm_, fun->end_position() - 1);
 840 }
 841
 842
 843 void FullCodeGenerator::SetStatementPosition(Statement* stmt) {
 844 #ifdef ENABLE_DEBUGGER_SUPPORT
 845   if (!isolate()->debugger()->IsDebuggerActive()) {
 846     CodeGenerator::RecordPositions(masm_, stmt->position());
 847   } else {
 848     // Check if the statement will be breakable without adding a debug break
 849     // slot.
 850     BreakableStatementChecker checker(zone());
 851     checker.Check(stmt);
 852     // Record the statement position right here if the statement is not
 853     // breakable. For breakable statements the actual recording of the
 854     // position will be postponed to the breakable code (typically an IC).
 855     bool position_recorded = CodeGenerator::RecordPositions(
 856         masm_, stmt->position(), !checker.is_breakable());
 857     // If the position recording did record a new position generate a debug
 858     // break slot to make the statement breakable.
 859     if (position_recorded) {
 860       Debug::GenerateSlot(masm_);
 861     }
 862   }
 863 #else
 864   CodeGenerator::RecordPositions(masm_, stmt->position());
 865 #endif
 866 }
 867
 868
 869 void FullCodeGenerator::SetExpressionPosition(Expression* expr) {
 870 #ifdef ENABLE_DEBUGGER_SUPPORT
 871   if (!isolate()->debugger()->IsDebuggerActive()) {
 872     CodeGenerator::RecordPositions(masm_, expr->position());
 873   } else {
 874     // Check if the expression will be breakable without adding a debug break
 875     // slot.
 876     BreakableStatementChecker checker(zone());
 877     checker.Check(expr);
 878     // Record a statement position right here if the expression is not
 879     // breakable. For breakable expressions the actual recording of the
 880     // position will be postponed to the breakable code (typically an IC).
 881     // NOTE this will record a statement position for something which might
 882     // not be a statement. As stepping in the debugger will only stop at
 883     // statement positions this is used for e.g. the condition expression of
 884     // a do while loop.
 885     bool position_recorded = CodeGenerator::RecordPositions(
 886         masm_, expr->position(), !checker.is_breakable());
 887     // If the position recording did record a new position generate a debug
 888     // break slot to make the statement breakable.
 889     if (position_recorded) {
 890       Debug::GenerateSlot(masm_);
 891     }
 892   }
 893 #else
 894   CodeGenerator::RecordPositions(masm_, pos);
 895 #endif
 896 }
 897
 898
 899 void FullCodeGenerator::SetStatementPosition(int pos) {
 900   CodeGenerator::RecordPositions(masm_, pos);
 901 }
 902
 903
 904 void FullCodeGenerator::SetSourcePosition(int pos) {
 905   if (pos != RelocInfo::kNoPosition) {
 906     masm_->positions_recorder()->RecordPosition(pos);
 907   }
 908 }
 909
 910
 911 // Lookup table for code generators for  special runtime calls which are
 912 // generated inline.
 913 #define INLINE_FUNCTION_GENERATOR_ADDRESS(Name, argc, ressize)          \
 914     &FullCodeGenerator::Emit##Name,
 915
 916 const FullCodeGenerator::InlineFunctionGenerator
 917   FullCodeGenerator::kInlineFunctionGenerators[] = {
 918     INLINE_FUNCTION_LIST(INLINE_FUNCTION_GENERATOR_ADDRESS)
 919     INLINE_RUNTIME_FUNCTION_LIST(INLINE_FUNCTION_GENERATOR_ADDRESS)
 920   };
 921 #undef INLINE_FUNCTION_GENERATOR_ADDRESS
 922
 923
 924 FullCodeGenerator::InlineFunctionGenerator
 925   FullCodeGenerator::FindInlineFunctionGenerator(Runtime::FunctionId id) {
 926     int lookup_index =
 927         static_cast<int>(id) - static_cast<int>(Runtime::kFirstInlineFunction);
 928     ASSERT(lookup_index >= 0);
 929     ASSERT(static_cast<size_t>(lookup_index) <
 930            ARRAY_SIZE(kInlineFunctionGenerators));
 931     return kInlineFunctionGenerators[lookup_index];
 932 }
 933
 934
 935 void FullCodeGenerator::EmitInlineRuntimeCall(CallRuntime* expr) {
 936   const Runtime::Function* function = expr->function();
 937   ASSERT(function != NULL);
 938   ASSERT(function->intrinsic_type == Runtime::INLINE);
 939   InlineFunctionGenerator generator =
 940       FindInlineFunctionGenerator(function->function_id);
 941   ((*this).*(generator))(expr);
 942 }
 943
 944
 945 void FullCodeGenerator::EmitGeneratorNext(CallRuntime* expr) {
 946   ZoneList<Expression*>* args = expr->arguments();
 947   ASSERT(args->length() == 2);
 948   EmitGeneratorResume(args->at(0), args->at(1), JSGeneratorObject::NEXT);
 949 }
 950
 951
 952 void FullCodeGenerator::EmitGeneratorThrow(CallRuntime* expr) {
 953   ZoneList<Expression*>* args = expr->arguments();
 954   ASSERT(args->length() == 2);
 955   EmitGeneratorResume(args->at(0), args->at(1), JSGeneratorObject::THROW);
 956 }
 957
 958
 959 void FullCodeGenerator::EmitDebugBreakInOptimizedCode(CallRuntime* expr) {
 960   context()->Plug(handle(Smi::FromInt(0), isolate()));
 961 }
 962
 963
 964 void FullCodeGenerator::VisitBinaryOperation(BinaryOperation* expr) {
 965   switch (expr->op()) {
 966     case Token::COMMA:
 967       return VisitComma(expr);
 968     case Token::OR:
 969     case Token::AND:
 970       return VisitLogicalExpression(expr);
 971     default:
 972       return VisitArithmeticExpression(expr);
 973   }
 974 }
 975
 976
 977 void FullCodeGenerator::VisitInDuplicateContext(Expression* expr) {
 978   if (context()->IsEffect()) {
 979     VisitForEffect(expr);
 980   } else if (context()->IsAccumulatorValue()) {
 981     VisitForAccumulatorValue(expr);
 982   } else if (context()->IsStackValue()) {
 983     VisitForStackValue(expr);
 984   } else if (context()->IsTest()) {
 985     const TestContext* test = TestContext::cast(context());
 986     VisitForControl(expr, test->true_label(), test->false_label(),
 987                     test->fall_through());
 988   }
 989 }
 990
 991
 992 void FullCodeGenerator::VisitComma(BinaryOperation* expr) {
 993   Comment cmnt(masm_, "[ Comma");
 994   VisitForEffect(expr->left());
 995   VisitInDuplicateContext(expr->right());
 996 }
 997
 998
 999 void FullCodeGenerator::VisitLogicalExpression(BinaryOperation* expr) {
1000   bool is_logical_and = expr->op() == Token::AND;
1001   Comment cmnt(masm_, is_logical_and ? "[ Logical AND" :  "[ Logical OR");
1002   Expression* left = expr->left();
1003   Expression* right = expr->right();
1004   BailoutId right_id = expr->RightId();
1005   Label done;
1006
1007   if (context()->IsTest()) {
1008     Label eval_right;
1009     const TestContext* test = TestContext::cast(context());
1010     if (is_logical_and) {
1011       VisitForControl(left, &eval_right, test->false_label(), &eval_right);
1012     } else {
1013       VisitForControl(left, test->true_label(), &eval_right, &eval_right);
1014     }
1015     PrepareForBailoutForId(right_id, NO_REGISTERS);
1016     __ bind(&eval_right);
1017
1018   } else if (context()->IsAccumulatorValue()) {
1019     VisitForAccumulatorValue(left);
1020     // We want the value in the accumulator for the test, and on the stack in
1021     // case we need it.
1022     __ Push(result_register());
1023     Label discard, restore;
1024     if (is_logical_and) {
1025       DoTest(left, &discard, &restore, &restore);
1026     } else {
1027       DoTest(left, &restore, &discard, &restore);
1028     }
1029     __ bind(&restore);
1030     __ Pop(result_register());
1031     __ jmp(&done);
1032     __ bind(&discard);
1033     __ Drop(1);
1034     PrepareForBailoutForId(right_id, NO_REGISTERS);
1035
1036   } else if (context()->IsStackValue()) {
1037     VisitForAccumulatorValue(left);
1038     // We want the value in the accumulator for the test, and on the stack in
1039     // case we need it.
1040     __ Push(result_register());
1041     Label discard;
1042     if (is_logical_and) {
1043       DoTest(left, &discard, &done, &discard);
1044     } else {
1045       DoTest(left, &done, &discard, &discard);
1046     }
1047     __ bind(&discard);
1048     __ Drop(1);
1049     PrepareForBailoutForId(right_id, NO_REGISTERS);
1050
1051   } else {
1052     ASSERT(context()->IsEffect());
1053     Label eval_right;
1054     if (is_logical_and) {
1055       VisitForControl(left, &eval_right, &done, &eval_right);
1056     } else {
1057       VisitForControl(left, &done, &eval_right, &eval_right);
1058     }
1059     PrepareForBailoutForId(right_id, NO_REGISTERS);
1060     __ bind(&eval_right);
1061   }
1062
1063   VisitInDuplicateContext(right);
1064   __ bind(&done);
1065 }
1066
1067
1068 void FullCodeGenerator::VisitArithmeticExpression(BinaryOperation* expr) {
1069   Token::Value op = expr->op();
1070   Comment cmnt(masm_, "[ ArithmeticExpression");
1071   Expression* left = expr->left();
1072   Expression* right = expr->right();
1073   OverwriteMode mode =
1074       left->ResultOverwriteAllowed()
1075       ? OVERWRITE_LEFT
1076       : (right->ResultOverwriteAllowed() ? OVERWRITE_RIGHT : NO_OVERWRITE);
1077
1078   VisitForStackValue(left);
1079   VisitForAccumulatorValue(right);
1080
1081   SetSourcePosition(expr->position());
1082   if (ShouldInlineSmiCase(op)) {
1083     EmitInlineSmiBinaryOp(expr, op, mode, left, right);
1084   } else {
1085     EmitBinaryOp(expr, op, mode);
1086   }
1087 }
1088
1089
1090 void FullCodeGenerator::VisitBlock(Block* stmt) {
1091   Comment cmnt(masm_, "[ Block");
1092   NestedBlock nested_block(this, stmt);
1093   SetStatementPosition(stmt);
1094
1095   Scope* saved_scope = scope();
1096   // Push a block context when entering a block with block scoped variables.
1097   if (stmt->scope() != NULL) {
1098     scope_ = stmt->scope();
1099     ASSERT(!scope_->is_module_scope());
1100     { Comment cmnt(masm_, "[ Extend block context");
1101       Handle<ScopeInfo> scope_info = scope_->GetScopeInfo();
1102       int heap_slots = scope_info->ContextLength() - Context::MIN_CONTEXT_SLOTS;
1103       __ Push(scope_info);
1104       PushFunctionArgumentForContextAllocation();
1105       if (heap_slots <= FastNewBlockContextStub::kMaximumSlots) {
1106         FastNewBlockContextStub stub(heap_slots);
1107         __ CallStub(&stub);
1108       } else {
1109         __ CallRuntime(Runtime::kPushBlockContext, 2);
1110       }
1111
1112       // Replace the context stored in the frame.
1113       StoreToFrameField(StandardFrameConstants::kContextOffset,
1114                         context_register());
1115     }
1116     { Comment cmnt(masm_, "[ Declarations");
1117       VisitDeclarations(scope_->declarations());
1118     }
1119   }
1120
1121   PrepareForBailoutForId(stmt->EntryId(), NO_REGISTERS);
1122   VisitStatements(stmt->statements());
1123   scope_ = saved_scope;
1124   __ bind(nested_block.break_label());
1125   PrepareForBailoutForId(stmt->ExitId(), NO_REGISTERS);
1126
1127   // Pop block context if necessary.
1128   if (stmt->scope() != NULL) {
1129     LoadContextField(context_register(), Context::PREVIOUS_INDEX);
1130     // Update local stack frame context field.
1131     StoreToFrameField(StandardFrameConstants::kContextOffset,
1132                       context_register());
1133   }
1134 }
1135
1136
1137 void FullCodeGenerator::VisitModuleStatement(ModuleStatement* stmt) {
1138   Comment cmnt(masm_, "[ Module context");
1139
1140   __ Push(Smi::FromInt(stmt->proxy()->interface()->Index()));
1141   __ Push(Smi::FromInt(0));
1142   __ CallRuntime(Runtime::kPushModuleContext, 2);
1143   StoreToFrameField(
1144       StandardFrameConstants::kContextOffset, context_register());
1145
1146   Scope* saved_scope = scope_;
1147   scope_ = stmt->body()->scope();
1148   VisitStatements(stmt->body()->statements());
1149   scope_ = saved_scope;
1150   LoadContextField(context_register(), Context::PREVIOUS_INDEX);
1151   // Update local stack frame context field.
1152   StoreToFrameField(StandardFrameConstants::kContextOffset,
1153                     context_register());
1154 }
1155
1156
1157 void FullCodeGenerator::VisitExpressionStatement(ExpressionStatement* stmt) {
1158   Comment cmnt(masm_, "[ ExpressionStatement");
1159   SetStatementPosition(stmt);
1160   VisitForEffect(stmt->expression());
1161 }
1162
1163
1164 void FullCodeGenerator::VisitEmptyStatement(EmptyStatement* stmt) {
1165   Comment cmnt(masm_, "[ EmptyStatement");
1166   SetStatementPosition(stmt);
1167 }
1168
1169
1170 void FullCodeGenerator::VisitIfStatement(IfStatement* stmt) {
1171   Comment cmnt(masm_, "[ IfStatement");
1172   SetStatementPosition(stmt);
1173   Label then_part, else_part, done;
1174
1175   if (stmt->HasElseStatement()) {
1176     VisitForControl(stmt->condition(), &then_part, &else_part, &then_part);
1177     PrepareForBailoutForId(stmt->ThenId(), NO_REGISTERS);
1178     __ bind(&then_part);
1179     Visit(stmt->then_statement());
1180     __ jmp(&done);
1181
1182     PrepareForBailoutForId(stmt->ElseId(), NO_REGISTERS);
1183     __ bind(&else_part);
1184     Visit(stmt->else_statement());
1185   } else {
1186     VisitForControl(stmt->condition(), &then_part, &done, &then_part);
1187     PrepareForBailoutForId(stmt->ThenId(), NO_REGISTERS);
1188     __ bind(&then_part);
1189     Visit(stmt->then_statement());
1190
1191     PrepareForBailoutForId(stmt->ElseId(), NO_REGISTERS);
1192   }
1193   __ bind(&done);
1194   PrepareForBailoutForId(stmt->IfId(), NO_REGISTERS);
1195 }
1196
1197
1198 void FullCodeGenerator::VisitContinueStatement(ContinueStatement* stmt) {
1199   Comment cmnt(masm_,  "[ ContinueStatement");
1200   SetStatementPosition(stmt);
1201   NestedStatement* current = nesting_stack_;
1202   int stack_depth = 0;
1203   int context_length = 0;
1204   // When continuing, we clobber the unpredictable value in the accumulator
1205   // with one that's safe for GC.  If we hit an exit from the try block of
1206   // try...finally on our way out, we will unconditionally preserve the
1207   // accumulator on the stack.
1208   ClearAccumulator();
1209   while (!current->IsContinueTarget(stmt->target())) {
1210     current = current->Exit(&stack_depth, &context_length);
1211   }
1212   __ Drop(stack_depth);
1213   if (context_length > 0) {
1214     while (context_length > 0) {
1215       LoadContextField(context_register(), Context::PREVIOUS_INDEX);
1216       --context_length;
1217     }
1218     StoreToFrameField(StandardFrameConstants::kContextOffset,
1219                       context_register());
1220   }
1221
1222   __ jmp(current->AsIteration()->continue_label());
1223 }
1224
1225
1226 void FullCodeGenerator::VisitBreakStatement(BreakStatement* stmt) {
1227   Comment cmnt(masm_,  "[ BreakStatement");
1228   SetStatementPosition(stmt);
1229   NestedStatement* current = nesting_stack_;
1230   int stack_depth = 0;
1231   int context_length = 0;
1232   // When breaking, we clobber the unpredictable value in the accumulator
1233   // with one that's safe for GC.  If we hit an exit from the try block of
1234   // try...finally on our way out, we will unconditionally preserve the
1235   // accumulator on the stack.
1236   ClearAccumulator();
1237   while (!current->IsBreakTarget(stmt->target())) {
1238     current = current->Exit(&stack_depth, &context_length);
1239   }
1240   __ Drop(stack_depth);
1241   if (context_length > 0) {
1242     while (context_length > 0) {
1243       LoadContextField(context_register(), Context::PREVIOUS_INDEX);
1244       --context_length;
1245     }
1246     StoreToFrameField(StandardFrameConstants::kContextOffset,
1247                       context_register());
1248   }
1249
1250   __ jmp(current->AsBreakable()->break_label());
1251 }
1252
1253
1254 void FullCodeGenerator::EmitUnwindBeforeReturn() {
1255   NestedStatement* current = nesting_stack_;
1256   int stack_depth = 0;
1257   int context_length = 0;
1258   while (current != NULL) {
1259     current = current->Exit(&stack_depth, &context_length);
1260   }
1261   __ Drop(stack_depth);
1262 }
1263
1264
1265 void FullCodeGenerator::VisitReturnStatement(ReturnStatement* stmt) {
1266   Comment cmnt(masm_, "[ ReturnStatement");
1267   SetStatementPosition(stmt);
1268   Expression* expr = stmt->expression();
1269   VisitForAccumulatorValue(expr);
1270   EmitUnwindBeforeReturn();
1271   EmitReturnSequence();
1272 }
1273
1274
1275 void FullCodeGenerator::VisitWithStatement(WithStatement* stmt) {
1276   Comment cmnt(masm_, "[ WithStatement");
1277   SetStatementPosition(stmt);
1278
1279   VisitForStackValue(stmt->expression());
1280   PushFunctionArgumentForContextAllocation();
1281   __ CallRuntime(Runtime::kPushWithContext, 2);
1282   StoreToFrameField(StandardFrameConstants::kContextOffset, context_register());
1283
1284   Scope* saved_scope = scope();
1285   scope_ = stmt->scope();
1286   { WithOrCatch body(this);
1287     Visit(stmt->statement());
1288   }
1289   scope_ = saved_scope;
1290
1291   // Pop context.
1292   LoadContextField(context_register(), Context::PREVIOUS_INDEX);
1293   // Update local stack frame context field.
1294   StoreToFrameField(StandardFrameConstants::kContextOffset, context_register());
1295 }
1296
1297
1298 void FullCodeGenerator::VisitDoWhileStatement(DoWhileStatement* stmt) {
1299   Comment cmnt(masm_, "[ DoWhileStatement");
1300   SetStatementPosition(stmt);
1301   Label body, book_keeping;
1302
1303   Iteration loop_statement(this, stmt);
1304   increment_loop_depth();
1305
1306   __ bind(&body);
1307   Visit(stmt->body());
1308
1309   // Record the position of the do while condition and make sure it is
1310   // possible to break on the condition.
1311   __ bind(loop_statement.continue_label());
1312   PrepareForBailoutForId(stmt->ContinueId(), NO_REGISTERS);
1313   SetExpressionPosition(stmt->cond());
1314   VisitForControl(stmt->cond(),
1315                   &book_keeping,
1316                   loop_statement.break_label(),
1317                   &book_keeping);
1318
1319   // Check stack before looping.
1320   PrepareForBailoutForId(stmt->BackEdgeId(), NO_REGISTERS);
1321   __ bind(&book_keeping);
1322   EmitBackEdgeBookkeeping(stmt, &body);
1323   __ jmp(&body);
1324
1325   PrepareForBailoutForId(stmt->ExitId(), NO_REGISTERS);
1326   __ bind(loop_statement.break_label());
1327   decrement_loop_depth();
1328 }
1329
1330
1331 void FullCodeGenerator::VisitWhileStatement(WhileStatement* stmt) {
1332   Comment cmnt(masm_, "[ WhileStatement");
1333   Label test, body;
1334
1335   Iteration loop_statement(this, stmt);
1336   increment_loop_depth();
1337
1338   // Emit the test at the bottom of the loop.
1339   __ jmp(&test);
1340
1341   PrepareForBailoutForId(stmt->BodyId(), NO_REGISTERS);
1342   __ bind(&body);
1343   Visit(stmt->body());
1344
1345   // Emit the statement position here as this is where the while
1346   // statement code starts.
1347   __ bind(loop_statement.continue_label());
1348   SetStatementPosition(stmt);
1349
1350   // Check stack before looping.
1351   EmitBackEdgeBookkeeping(stmt, &body);
1352
1353   __ bind(&test);
1354   VisitForControl(stmt->cond(),
1355                   &body,
1356                   loop_statement.break_label(),
1357                   loop_statement.break_label());
1358
1359   PrepareForBailoutForId(stmt->ExitId(), NO_REGISTERS);
1360   __ bind(loop_statement.break_label());
1361   decrement_loop_depth();
1362 }
1363
1364
1365 void FullCodeGenerator::VisitForStatement(ForStatement* stmt) {
1366   Comment cmnt(masm_, "[ ForStatement");
1367   Label test, body;
1368
1369   Iteration loop_statement(this, stmt);
1370
1371   // Set statement position for a break slot before entering the for-body.
1372   SetStatementPosition(stmt);
1373
1374   if (stmt->init() != NULL) {
1375     Visit(stmt->init());
1376   }
1377
1378   increment_loop_depth();
1379   // Emit the test at the bottom of the loop (even if empty).
1380   __ jmp(&test);
1381
1382   PrepareForBailoutForId(stmt->BodyId(), NO_REGISTERS);
1383   __ bind(&body);
1384   Visit(stmt->body());
1385
1386   PrepareForBailoutForId(stmt->ContinueId(), NO_REGISTERS);
1387   __ bind(loop_statement.continue_label());
1388   if (stmt->next() != NULL) {
1389     Visit(stmt->next());
1390   }
1391
1392   // Emit the statement position here as this is where the for
1393   // statement code starts.
1394   SetStatementPosition(stmt);
1395
1396   // Check stack before looping.
1397   EmitBackEdgeBookkeeping(stmt, &body);
1398
1399   __ bind(&test);
1400   if (stmt->cond() != NULL) {
1401     VisitForControl(stmt->cond(),
1402                     &body,
1403                     loop_statement.break_label(),
1404                     loop_statement.break_label());
1405   } else {
1406     __ jmp(&body);
1407   }
1408
1409   PrepareForBailoutForId(stmt->ExitId(), NO_REGISTERS);
1410   __ bind(loop_statement.break_label());
1411   decrement_loop_depth();
1412 }
1413
1414
1415 void FullCodeGenerator::VisitTryCatchStatement(TryCatchStatement* stmt) {
1416   Comment cmnt(masm_, "[ TryCatchStatement");
1417   SetStatementPosition(stmt);
1418   // The try block adds a handler to the exception handler chain before
1419   // entering, and removes it again when exiting normally.  If an exception
1420   // is thrown during execution of the try block, the handler is consumed
1421   // and control is passed to the catch block with the exception in the
1422   // result register.
1423
1424   Label try_entry, handler_entry, exit;
1425   __ jmp(&try_entry);
1426   __ bind(&handler_entry);
1427   handler_table()->set(stmt->index(), Smi::FromInt(handler_entry.pos()));
1428   // Exception handler code, the exception is in the result register.
1429   // Extend the context before executing the catch block.
1430   { Comment cmnt(masm_, "[ Extend catch context");
1431     __ Push(stmt->variable()->name());
1432     __ Push(result_register());
1433     PushFunctionArgumentForContextAllocation();
1434     __ CallRuntime(Runtime::kPushCatchContext, 3);
1435     StoreToFrameField(StandardFrameConstants::kContextOffset,
1436                       context_register());
1437   }
1438
1439   Scope* saved_scope = scope();
1440   scope_ = stmt->scope();
1441   ASSERT(scope_->declarations()->is_empty());
1442   { WithOrCatch catch_body(this);
1443     Visit(stmt->catch_block());
1444   }
1445   // Restore the context.
1446   LoadContextField(context_register(), Context::PREVIOUS_INDEX);
1447   StoreToFrameField(StandardFrameConstants::kContextOffset, context_register());
1448   scope_ = saved_scope;
1449   __ jmp(&exit);
1450
1451   // Try block code. Sets up the exception handler chain.
1452   __ bind(&try_entry);
1453   __ PushTryHandler(StackHandler::CATCH, stmt->index());
1454   { TryCatch try_body(this);
1455     Visit(stmt->try_block());
1456   }
1457   __ PopTryHandler();
1458   __ bind(&exit);
1459 }
1460
1461
1462 void FullCodeGenerator::VisitTryFinallyStatement(TryFinallyStatement* stmt) {
1463   Comment cmnt(masm_, "[ TryFinallyStatement");
1464   SetStatementPosition(stmt);
1465   // Try finally is compiled by setting up a try-handler on the stack while
1466   // executing the try body, and removing it again afterwards.
1467   //
1468   // The try-finally construct can enter the finally block in three ways:
1469   // 1. By exiting the try-block normally. This removes the try-handler and
1470   //    calls the finally block code before continuing.
1471   // 2. By exiting the try-block with a function-local control flow transfer
1472   //    (break/continue/return). The site of the, e.g., break removes the
1473   //    try handler and calls the finally block code before continuing
1474   //    its outward control transfer.
1475   // 3. By exiting the try-block with a thrown exception.
1476   //    This can happen in nested function calls. It traverses the try-handler
1477   //    chain and consumes the try-handler entry before jumping to the
1478   //    handler code. The handler code then calls the finally-block before
1479   //    rethrowing the exception.
1480   //
1481   // The finally block must assume a return address on top of the stack
1482   // (or in the link register on ARM chips) and a value (return value or
1483   // exception) in the result register (rax/eax/r0), both of which must
1484   // be preserved. The return address isn't GC-safe, so it should be
1485   // cooked before GC.
1486   Label try_entry, handler_entry, finally_entry;
1487
1488   // Jump to try-handler setup and try-block code.
1489   __ jmp(&try_entry);
1490   __ bind(&handler_entry);
1491   handler_table()->set(stmt->index(), Smi::FromInt(handler_entry.pos()));
1492   // Exception handler code.  This code is only executed when an exception
1493   // is thrown.  The exception is in the result register, and must be
1494   // preserved by the finally block.  Call the finally block and then
1495   // rethrow the exception if it returns.
1496   __ Call(&finally_entry);
1497   __ Push(result_register());
1498   __ CallRuntime(Runtime::kReThrow, 1);
1499
1500   // Finally block implementation.
1501   __ bind(&finally_entry);
1502   EnterFinallyBlock();
1503   { Finally finally_body(this);
1504     Visit(stmt->finally_block());
1505   }
1506   ExitFinallyBlock();  // Return to the calling code.
1507
1508   // Set up try handler.
1509   __ bind(&try_entry);
1510   __ PushTryHandler(StackHandler::FINALLY, stmt->index());
1511   { TryFinally try_body(this, &finally_entry);
1512     Visit(stmt->try_block());
1513   }
1514   __ PopTryHandler();
1515   // Execute the finally block on the way out.  Clobber the unpredictable
1516   // value in the result register with one that's safe for GC because the
1517   // finally block will unconditionally preserve the result register on the
1518   // stack.
1519   ClearAccumulator();
1520   __ Call(&finally_entry);
1521 }
1522
1523
1524 void FullCodeGenerator::VisitDebuggerStatement(DebuggerStatement* stmt) {
1525 #ifdef ENABLE_DEBUGGER_SUPPORT
1526   Comment cmnt(masm_, "[ DebuggerStatement");
1527   SetStatementPosition(stmt);
1528
1529   __ DebugBreak();
1530   // Ignore the return value.
1531 #endif
1532 }
1533
1534
1535 void FullCodeGenerator::VisitCaseClause(CaseClause* clause) {
1536   UNREACHABLE();
1537 }
1538
1539
1540 void FullCodeGenerator::VisitConditional(Conditional* expr) {
1541   Comment cmnt(masm_, "[ Conditional");
1542   Label true_case, false_case, done;
1543   VisitForControl(expr->condition(), &true_case, &false_case, &true_case);
1544
1545   PrepareForBailoutForId(expr->ThenId(), NO_REGISTERS);
1546   __ bind(&true_case);
1547   SetExpressionPosition(expr->then_expression());
1548   if (context()->IsTest()) {
1549     const TestContext* for_test = TestContext::cast(context());
1550     VisitForControl(expr->then_expression(),
1551                     for_test->true_label(),
1552                     for_test->false_label(),
1553                     NULL);
1554   } else {
1555     VisitInDuplicateContext(expr->then_expression());
1556     __ jmp(&done);
1557   }
1558
1559   PrepareForBailoutForId(expr->ElseId(), NO_REGISTERS);
1560   __ bind(&false_case);
1561   SetExpressionPosition(expr->else_expression());
1562   VisitInDuplicateContext(expr->else_expression());
1563   // If control flow falls through Visit, merge it with true case here.
1564   if (!context()->IsTest()) {
1565     __ bind(&done);
1566   }
1567 }
1568
1569
1570 void FullCodeGenerator::VisitLiteral(Literal* expr) {
1571   Comment cmnt(masm_, "[ Literal");
1572   context()->Plug(expr->value());
1573 }
1574
1575
1576 void FullCodeGenerator::VisitFunctionLiteral(FunctionLiteral* expr) {
1577   Comment cmnt(masm_, "[ FunctionLiteral");
1578
1579   // Build the function boilerplate and instantiate it.
1580   Handle<SharedFunctionInfo> function_info =
1581       Compiler::BuildFunctionInfo(expr, script());
1582   if (function_info.is_null()) {
1583     SetStackOverflow();
1584     return;
1585   }
1586   EmitNewClosure(function_info, expr->pretenure());
1587 }
1588
1589
1590 void FullCodeGenerator::VisitNativeFunctionLiteral(
1591     NativeFunctionLiteral* expr) {
1592   Comment cmnt(masm_, "[ NativeFunctionLiteral");
1593
1594   // Compute the function template for the native function.
1595   Handle<String> name = expr->name();
1596   v8::Handle<v8::FunctionTemplate> fun_template =
1597       expr->extension()->GetNativeFunctionTemplate(
1598           reinterpret_cast<v8::Isolate*>(isolate()), v8::Utils::ToLocal(name));
1599   ASSERT(!fun_template.IsEmpty());
1600
1601   // Instantiate the function and create a shared function info from it.
1602   Handle<JSFunction> fun = Utils::OpenHandle(*fun_template->GetFunction());
1603   const int literals = fun->NumberOfLiterals();
1604   Handle<Code> code = Handle<Code>(fun->shared()->code());
1605   Handle<Code> construct_stub = Handle<Code>(fun->shared()->construct_stub());
1606   bool is_generator = false;
1607   Handle<SharedFunctionInfo> shared =
1608       isolate()->factory()->NewSharedFunctionInfo(name, literals, is_generator,
1609           code, Handle<ScopeInfo>(fun->shared()->scope_info()));
1610   shared->set_construct_stub(*construct_stub);
1611
1612   // Copy the function data to the shared function info.
1613   shared->set_function_data(fun->shared()->function_data());
1614   int parameters = fun->shared()->formal_parameter_count();
1615   shared->set_formal_parameter_count(parameters);
1616
1617   EmitNewClosure(shared, false);
1618 }
1619
1620
1621 void FullCodeGenerator::VisitThrow(Throw* expr) {
1622   Comment cmnt(masm_, "[ Throw");
1623   VisitForStackValue(expr->exception());
1624   __ CallRuntime(Runtime::kThrow, 1);
1625   // Never returns here.
1626 }
1627
1628
1629 FullCodeGenerator::NestedStatement* FullCodeGenerator::TryCatch::Exit(
1630     int* stack_depth,
1631     int* context_length) {
1632   // The macros used here must preserve the result register.
1633   __ Drop(*stack_depth);
1634   __ PopTryHandler();
1635   *stack_depth = 0;
1636   return previous_;
1637 }
1638
1639
1640 bool FullCodeGenerator::TryLiteralCompare(CompareOperation* expr) {
1641   Expression* sub_expr;
1642   Handle<String> check;
1643   if (expr->IsLiteralCompareTypeof(&sub_expr, &check)) {
1644     EmitLiteralCompareTypeof(expr, sub_expr, check);
1645     return true;
1646   }
1647
1648   if (expr->IsLiteralCompareUndefined(&sub_expr, isolate())) {
1649     EmitLiteralCompareNil(expr, sub_expr, kUndefinedValue);
1650     return true;
1651   }
1652
1653   if (expr->IsLiteralCompareNull(&sub_expr)) {
1654     EmitLiteralCompareNil(expr, sub_expr, kNullValue);
1655     return true;
1656   }
1657
1658   return false;
1659 }
1660
1661
1662 void BackEdgeTable::Patch(Isolate* isolate, Code* unoptimized) {
1663   DisallowHeapAllocation no_gc;
1664   Code* patch = isolate->builtins()->builtin(Builtins::kOnStackReplacement);
1665
1666   // Iterate over the back edge table and patch every interrupt
1667   // call to an unconditional call to the replacement code.
1668   int loop_nesting_level = unoptimized->allow_osr_at_loop_nesting_level();
1669
1670   BackEdgeTable back_edges(unoptimized, &no_gc);
1671   for (uint32_t i = 0; i < back_edges.length(); i++) {
1672     if (static_cast<int>(back_edges.loop_depth(i)) == loop_nesting_level) {
1673       ASSERT_EQ(INTERRUPT, GetBackEdgeState(isolate,
1674                                             unoptimized,
1675                                             back_edges.pc(i)));
1676       PatchAt(unoptimized, back_edges.pc(i), ON_STACK_REPLACEMENT, patch);
1677     }
1678   }
1679
1680   unoptimized->set_back_edges_patched_for_osr(true);
1681   ASSERT(Verify(isolate, unoptimized, loop_nesting_level));
1682 }
1683
1684
1685 void BackEdgeTable::Revert(Isolate* isolate, Code* unoptimized) {
1686   DisallowHeapAllocation no_gc;
1687   Code* patch = isolate->builtins()->builtin(Builtins::kInterruptCheck);
1688
1689   // Iterate over the back edge table and revert the patched interrupt calls.
1690   ASSERT(unoptimized->back_edges_patched_for_osr());
1691   int loop_nesting_level = unoptimized->allow_osr_at_loop_nesting_level();
1692
1693   BackEdgeTable back_edges(unoptimized, &no_gc);
1694   for (uint32_t i = 0; i < back_edges.length(); i++) {
1695     if (static_cast<int>(back_edges.loop_depth(i)) <= loop_nesting_level) {
1696       ASSERT_NE(INTERRUPT, GetBackEdgeState(isolate,
1697                                             unoptimized,
1698                                             back_edges.pc(i)));
1699       PatchAt(unoptimized, back_edges.pc(i), INTERRUPT, patch);
1700     }
1701   }
1702
1703   unoptimized->set_back_edges_patched_for_osr(false);
1704   unoptimized->set_allow_osr_at_loop_nesting_level(0);
1705   // Assert that none of the back edges are patched anymore.
1706   ASSERT(Verify(isolate, unoptimized, -1));
1707 }
1708
1709
1710 void BackEdgeTable::AddStackCheck(Handle<Code> code, uint32_t pc_offset) {
1711   DisallowHeapAllocation no_gc;
1712   Isolate* isolate = code->GetIsolate();
1713   Address pc = code->instruction_start() + pc_offset;
1714   Code* patch = isolate->builtins()->builtin(Builtins::kOsrAfterStackCheck);
1715   PatchAt(*code, pc, OSR_AFTER_STACK_CHECK, patch);
1716 }
1717
1718
1719 void BackEdgeTable::RemoveStackCheck(Handle<Code> code, uint32_t pc_offset) {
1720   DisallowHeapAllocation no_gc;
1721   Isolate* isolate = code->GetIsolate();
1722   Address pc = code->instruction_start() + pc_offset;
1723
1724   if (OSR_AFTER_STACK_CHECK == GetBackEdgeState(isolate, *code, pc)) {
1725     Code* patch = isolate->builtins()->builtin(Builtins::kOnStackReplacement);
1726     PatchAt(*code, pc, ON_STACK_REPLACEMENT, patch);
1727   }
1728 }
1729
1730
1731 #ifdef DEBUG
1732 bool BackEdgeTable::Verify(Isolate* isolate,
1733                            Code* unoptimized,
1734                            int loop_nesting_level) {
1735   DisallowHeapAllocation no_gc;
1736   BackEdgeTable back_edges(unoptimized, &no_gc);
1737   for (uint32_t i = 0; i < back_edges.length(); i++) {
1738     uint32_t loop_depth = back_edges.loop_depth(i);
1739     CHECK_LE(static_cast<int>(loop_depth), Code::kMaxLoopNestingMarker);
1740     // Assert that all back edges for shallower loops (and only those)
1741     // have already been patched.
1742     CHECK_EQ((static_cast<int>(loop_depth) <= loop_nesting_level),
1743              GetBackEdgeState(isolate,
1744                               unoptimized,
1745                               back_edges.pc(i)) != INTERRUPT);
1746   }
1747   return true;
1748 }
1749 #endif  // DEBUG
1750
1751
1752 #undef __
1753
1754
1755 } }  // namespace v8::internal