Home | History | Annotate | Download | only in crankshaft 
      1 // Copyright 2012 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 
      5 #include "src/crankshaft/lithium.h"
      6 
      7 #include "src/ast/scopes.h"
      8 #include "src/codegen.h"
      9 
     10 #if V8_TARGET_ARCH_IA32
     11 #include "src/crankshaft/ia32/lithium-ia32.h"  // NOLINT
     12 #include "src/crankshaft/ia32/lithium-codegen-ia32.h"  // NOLINT
     13 #elif V8_TARGET_ARCH_X64
     14 #include "src/crankshaft/x64/lithium-x64.h"  // NOLINT
     15 #include "src/crankshaft/x64/lithium-codegen-x64.h"  // NOLINT
     16 #elif V8_TARGET_ARCH_ARM
     17 #include "src/crankshaft/arm/lithium-arm.h"  // NOLINT
     18 #include "src/crankshaft/arm/lithium-codegen-arm.h"  // NOLINT
     19 #elif V8_TARGET_ARCH_PPC
     20 #include "src/crankshaft/ppc/lithium-ppc.h"          // NOLINT
     21 #include "src/crankshaft/ppc/lithium-codegen-ppc.h"  // NOLINT
     22 #elif V8_TARGET_ARCH_MIPS
     23 #include "src/crankshaft/mips/lithium-mips.h"  // NOLINT
     24 #include "src/crankshaft/mips/lithium-codegen-mips.h"  // NOLINT
     25 #elif V8_TARGET_ARCH_ARM64
     26 #include "src/crankshaft/arm64/lithium-arm64.h"  // NOLINT
     27 #include "src/crankshaft/arm64/lithium-codegen-arm64.h"  // NOLINT
     28 #elif V8_TARGET_ARCH_MIPS64
     29 #include "src/crankshaft/mips64/lithium-mips64.h"  // NOLINT
     30 #include "src/crankshaft/mips64/lithium-codegen-mips64.h"  // NOLINT
     31 #elif V8_TARGET_ARCH_X87
     32 #include "src/crankshaft/x87/lithium-x87.h"  // NOLINT
     33 #include "src/crankshaft/x87/lithium-codegen-x87.h"  // NOLINT
     34 #elif V8_TARGET_ARCH_S390
     35 #include "src/crankshaft/s390/lithium-s390.h"          // NOLINT
     36 #include "src/crankshaft/s390/lithium-codegen-s390.h"  // NOLINT
     37 #else
     38 #error "Unknown architecture."
     39 #endif
     40 
     41 namespace v8 {
     42 namespace internal {
     43 
     44 const auto GetRegConfig = RegisterConfiguration::Crankshaft;
     45 
     46 void LOperand::PrintTo(StringStream* stream) {
     47   LUnallocated* unalloc = NULL;
     48   switch (kind()) {
     49     case INVALID:
     50       stream->Add("(0)");
     51       break;
     52     case UNALLOCATED:
     53       unalloc = LUnallocated::cast(this);
     54       stream->Add("v%d", unalloc->virtual_register());
     55       if (unalloc->basic_policy() == LUnallocated::FIXED_SLOT) {
     56         stream->Add("(=%dS)", unalloc->fixed_slot_index());
     57         break;
     58       }
     59       switch (unalloc->extended_policy()) {
     60         case LUnallocated::NONE:
     61           break;
     62         case LUnallocated::FIXED_REGISTER: {
     63           int reg_index = unalloc->fixed_register_index();
     64           if (reg_index < 0 || reg_index >= Register::kNumRegisters) {
     65             stream->Add("(=invalid_reg#%d)", reg_index);
     66           } else {
     67             const char* register_name =
     68                 GetRegConfig()->GetGeneralRegisterName(reg_index);
     69             stream->Add("(=%s)", register_name);
     70           }
     71           break;
     72         }
     73         case LUnallocated::FIXED_DOUBLE_REGISTER: {
     74           int reg_index = unalloc->fixed_register_index();
     75           if (reg_index < 0 || reg_index >= DoubleRegister::kMaxNumRegisters) {
     76             stream->Add("(=invalid_double_reg#%d)", reg_index);
     77           } else {
     78             const char* double_register_name =
     79                 GetRegConfig()->GetDoubleRegisterName(reg_index);
     80             stream->Add("(=%s)", double_register_name);
     81           }
     82           break;
     83         }
     84         case LUnallocated::MUST_HAVE_REGISTER:
     85           stream->Add("(R)");
     86           break;
     87         case LUnallocated::MUST_HAVE_DOUBLE_REGISTER:
     88           stream->Add("(D)");
     89           break;
     90         case LUnallocated::WRITABLE_REGISTER:
     91           stream->Add("(WR)");
     92           break;
     93         case LUnallocated::SAME_AS_FIRST_INPUT:
     94           stream->Add("(1)");
     95           break;
     96         case LUnallocated::ANY:
     97           stream->Add("(-)");
     98           break;
     99       }
    100       break;
    101     case CONSTANT_OPERAND:
    102       stream->Add("[constant:%d]", index());
    103       break;
    104     case STACK_SLOT:
    105       stream->Add("[stack:%d]", index());
    106       break;
    107     case DOUBLE_STACK_SLOT:
    108       stream->Add("[double_stack:%d]", index());
    109       break;
    110     case REGISTER: {
    111       int reg_index = index();
    112       if (reg_index < 0 || reg_index >= Register::kNumRegisters) {
    113         stream->Add("(=invalid_reg#%d|R)", reg_index);
    114       } else {
    115         stream->Add("[%s|R]",
    116                     GetRegConfig()->GetGeneralRegisterName(reg_index));
    117       }
    118       break;
    119     }
    120     case DOUBLE_REGISTER: {
    121       int reg_index = index();
    122       if (reg_index < 0 || reg_index >= DoubleRegister::kMaxNumRegisters) {
    123         stream->Add("(=invalid_double_reg#%d|R)", reg_index);
    124       } else {
    125         stream->Add("[%s|R]", GetRegConfig()->GetDoubleRegisterName(reg_index));
    126       }
    127       break;
    128     }
    129   }
    130 }
    131 
    132 
    133 template<LOperand::Kind kOperandKind, int kNumCachedOperands>
    134 LSubKindOperand<kOperandKind, kNumCachedOperands>*
    135 LSubKindOperand<kOperandKind, kNumCachedOperands>::cache = NULL;
    136 
    137 
    138 template<LOperand::Kind kOperandKind, int kNumCachedOperands>
    139 void LSubKindOperand<kOperandKind, kNumCachedOperands>::SetUpCache() {
    140   if (cache) return;
    141   cache = new LSubKindOperand[kNumCachedOperands];
    142   for (int i = 0; i < kNumCachedOperands; i++) {
    143     cache[i].ConvertTo(kOperandKind, i);
    144   }
    145 }
    146 
    147 
    148 template<LOperand::Kind kOperandKind, int kNumCachedOperands>
    149 void LSubKindOperand<kOperandKind, kNumCachedOperands>::TearDownCache() {
    150   delete[] cache;
    151   cache = NULL;
    152 }
    153 
    154 
    155 void LOperand::SetUpCaches() {
    156 #define LITHIUM_OPERAND_SETUP(name, type, number) L##name::SetUpCache();
    157   LITHIUM_OPERAND_LIST(LITHIUM_OPERAND_SETUP)
    158 #undef LITHIUM_OPERAND_SETUP
    159 }
    160 
    161 
    162 void LOperand::TearDownCaches() {
    163 #define LITHIUM_OPERAND_TEARDOWN(name, type, number) L##name::TearDownCache();
    164   LITHIUM_OPERAND_LIST(LITHIUM_OPERAND_TEARDOWN)
    165 #undef LITHIUM_OPERAND_TEARDOWN
    166 }
    167 
    168 
    169 bool LParallelMove::IsRedundant() const {
    170   for (int i = 0; i < move_operands_.length(); ++i) {
    171     if (!move_operands_[i].IsRedundant()) return false;
    172   }
    173   return true;
    174 }
    175 
    176 
    177 void LParallelMove::PrintDataTo(StringStream* stream) const {
    178   bool first = true;
    179   for (int i = 0; i < move_operands_.length(); ++i) {
    180     if (!move_operands_[i].IsEliminated()) {
    181       LOperand* source = move_operands_[i].source();
    182       LOperand* destination = move_operands_[i].destination();
    183       if (!first) stream->Add(" ");
    184       first = false;
    185       if (source->Equals(destination)) {
    186         destination->PrintTo(stream);
    187       } else {
    188         destination->PrintTo(stream);
    189         stream->Add(" = ");
    190         source->PrintTo(stream);
    191       }
    192       stream->Add(";");
    193     }
    194   }
    195 }
    196 
    197 
    198 void LEnvironment::PrintTo(StringStream* stream) {
    199   stream->Add("[id=%d|", ast_id().ToInt());
    200   if (deoptimization_index() != Safepoint::kNoDeoptimizationIndex) {
    201     stream->Add("deopt_id=%d|", deoptimization_index());
    202   }
    203   stream->Add("parameters=%d|", parameter_count());
    204   stream->Add("arguments_stack_height=%d|", arguments_stack_height());
    205   for (int i = 0; i < values_.length(); ++i) {
    206     if (i != 0) stream->Add(";");
    207     if (values_[i] == NULL) {
    208       stream->Add("[hole]");
    209     } else {
    210       values_[i]->PrintTo(stream);
    211     }
    212   }
    213   stream->Add("]");
    214 }
    215 
    216 
    217 void LPointerMap::RecordPointer(LOperand* op, Zone* zone) {
    218   // Do not record arguments as pointers.
    219   if (op->IsStackSlot() && op->index() < 0) return;
    220   DCHECK(!op->IsDoubleRegister() && !op->IsDoubleStackSlot());
    221   pointer_operands_.Add(op, zone);
    222 }
    223 
    224 
    225 void LPointerMap::RemovePointer(LOperand* op) {
    226   // Do not record arguments as pointers.
    227   if (op->IsStackSlot() && op->index() < 0) return;
    228   DCHECK(!op->IsDoubleRegister() && !op->IsDoubleStackSlot());
    229   for (int i = 0; i < pointer_operands_.length(); ++i) {
    230     if (pointer_operands_[i]->Equals(op)) {
    231       pointer_operands_.Remove(i);
    232       --i;
    233     }
    234   }
    235 }
    236 
    237 
    238 void LPointerMap::RecordUntagged(LOperand* op, Zone* zone) {
    239   // Do not record arguments as pointers.
    240   if (op->IsStackSlot() && op->index() < 0) return;
    241   DCHECK(!op->IsDoubleRegister() && !op->IsDoubleStackSlot());
    242   untagged_operands_.Add(op, zone);
    243 }
    244 
    245 
    246 void LPointerMap::PrintTo(StringStream* stream) {
    247   stream->Add("{");
    248   for (int i = 0; i < pointer_operands_.length(); ++i) {
    249     if (i != 0) stream->Add(";");
    250     pointer_operands_[i]->PrintTo(stream);
    251   }
    252   stream->Add("}");
    253 }
    254 
    255 LChunk::LChunk(CompilationInfo* info, HGraph* graph)
    256     : base_frame_slots_(info->IsStub()
    257                             ? TypedFrameConstants::kFixedSlotCount
    258                             : StandardFrameConstants::kFixedSlotCount),
    259       current_frame_slots_(base_frame_slots_),
    260       info_(info),
    261       graph_(graph),
    262       instructions_(32, info->zone()),
    263       pointer_maps_(8, info->zone()),
    264       deprecation_dependencies_(32, info->zone()),
    265       stability_dependencies_(8, info->zone()) {}
    266 
    267 LLabel* LChunk::GetLabel(int block_id) const {
    268   HBasicBlock* block = graph_->blocks()->at(block_id);
    269   int first_instruction = block->first_instruction_index();
    270   return LLabel::cast(instructions_[first_instruction]);
    271 }
    272 
    273 
    274 int LChunk::LookupDestination(int block_id) const {
    275   LLabel* cur = GetLabel(block_id);
    276   while (cur->replacement() != NULL) {
    277     cur = cur->replacement();
    278   }
    279   return cur->block_id();
    280 }
    281 
    282 Label* LChunk::GetAssemblyLabel(int block_id) const {
    283   LLabel* label = GetLabel(block_id);
    284   DCHECK(!label->HasReplacement());
    285   return label->label();
    286 }
    287 
    288 
    289 void LChunk::MarkEmptyBlocks() {
    290   LPhase phase("L_Mark empty blocks", this);
    291   for (int i = 0; i < graph()->blocks()->length(); ++i) {
    292     HBasicBlock* block = graph()->blocks()->at(i);
    293     int first = block->first_instruction_index();
    294     int last = block->last_instruction_index();
    295     LInstruction* first_instr = instructions()->at(first);
    296     LInstruction* last_instr = instructions()->at(last);
    297 
    298     LLabel* label = LLabel::cast(first_instr);
    299     if (last_instr->IsGoto()) {
    300       LGoto* goto_instr = LGoto::cast(last_instr);
    301       if (label->IsRedundant() &&
    302           !label->is_loop_header()) {
    303         bool can_eliminate = true;
    304         for (int i = first + 1; i < last && can_eliminate; ++i) {
    305           LInstruction* cur = instructions()->at(i);
    306           if (cur->IsGap()) {
    307             LGap* gap = LGap::cast(cur);
    308             if (!gap->IsRedundant()) {
    309               can_eliminate = false;
    310             }
    311           } else {
    312             can_eliminate = false;
    313           }
    314         }
    315         if (can_eliminate) {
    316           label->set_replacement(GetLabel(goto_instr->block_id()));
    317         }
    318       }
    319     }
    320   }
    321 }
    322 
    323 
    324 void LChunk::AddInstruction(LInstruction* instr, HBasicBlock* block) {
    325   LInstructionGap* gap = new (zone()) LInstructionGap(block);
    326   gap->set_hydrogen_value(instr->hydrogen_value());
    327   int index = -1;
    328   if (instr->IsControl()) {
    329     instructions_.Add(gap, zone());
    330     index = instructions_.length();
    331     instructions_.Add(instr, zone());
    332   } else {
    333     index = instructions_.length();
    334     instructions_.Add(instr, zone());
    335     instructions_.Add(gap, zone());
    336   }
    337   if (instr->HasPointerMap()) {
    338     pointer_maps_.Add(instr->pointer_map(), zone());
    339     instr->pointer_map()->set_lithium_position(index);
    340   }
    341 }
    342 
    343 LConstantOperand* LChunk::DefineConstantOperand(HConstant* constant) {
    344   return LConstantOperand::Create(constant->id(), zone());
    345 }
    346 
    347 
    348 int LChunk::GetParameterStackSlot(int index) const {
    349   // The receiver is at index 0, the first parameter at index 1, so we
    350   // shift all parameter indexes down by the number of parameters, and
    351   // make sure they end up negative so they are distinguishable from
    352   // spill slots.
    353   int result = index - info()->num_parameters() - 1;
    354 
    355   DCHECK(result < 0);
    356   return result;
    357 }
    358 
    359 
    360 // A parameter relative to ebp in the arguments stub.
    361 int LChunk::ParameterAt(int index) {
    362   DCHECK(-1 <= index);  // -1 is the receiver.
    363   return (1 + info()->scope()->num_parameters() - index) *
    364       kPointerSize;
    365 }
    366 
    367 
    368 LGap* LChunk::GetGapAt(int index) const {
    369   return LGap::cast(instructions_[index]);
    370 }
    371 
    372 
    373 bool LChunk::IsGapAt(int index) const {
    374   return instructions_[index]->IsGap();
    375 }
    376 
    377 
    378 int LChunk::NearestGapPos(int index) const {
    379   while (!IsGapAt(index)) index--;
    380   return index;
    381 }
    382 
    383 
    384 void LChunk::AddGapMove(int index, LOperand* from, LOperand* to) {
    385   GetGapAt(index)->GetOrCreateParallelMove(
    386       LGap::START, zone())->AddMove(from, to, zone());
    387 }
    388 
    389 
    390 HConstant* LChunk::LookupConstant(LConstantOperand* operand) const {
    391   return HConstant::cast(graph_->LookupValue(operand->index()));
    392 }
    393 
    394 
    395 Representation LChunk::LookupLiteralRepresentation(
    396     LConstantOperand* operand) const {
    397   return graph_->LookupValue(operand->index())->representation();
    398 }
    399 
    400 
    401 void LChunk::CommitDependencies(Handle<Code> code) const {
    402   if (!code->is_optimized_code()) return;
    403   HandleScope scope(isolate());
    404 
    405   for (Handle<Map> map : deprecation_dependencies_) {
    406     DCHECK(!map->is_deprecated());
    407     DCHECK(map->CanBeDeprecated());
    408     Map::AddDependentCode(map, DependentCode::kTransitionGroup, code);
    409   }
    410 
    411   for (Handle<Map> map : stability_dependencies_) {
    412     DCHECK(map->is_stable());
    413     DCHECK(map->CanTransition());
    414     Map::AddDependentCode(map, DependentCode::kPrototypeCheckGroup, code);
    415   }
    416 
    417   info_->dependencies()->Commit(code);
    418 }
    419 
    420 
    421 LChunk* LChunk::NewChunk(HGraph* graph) {
    422   DisallowHandleAllocation no_handles;
    423   DisallowHeapAllocation no_gc;
    424   graph->DisallowAddingNewValues();
    425   int values = graph->GetMaximumValueID();
    426   CompilationInfo* info = graph->info();
    427   if (values > LUnallocated::kMaxVirtualRegisters) {
    428     info->AbortOptimization(kNotEnoughVirtualRegistersForValues);
    429     return NULL;
    430   }
    431   LAllocator allocator(values, graph);
    432   LChunkBuilder builder(info, graph, &allocator);
    433   LChunk* chunk = builder.Build();
    434   if (chunk == NULL) return NULL;
    435 
    436   if (!allocator.Allocate(chunk)) {
    437     info->AbortOptimization(kNotEnoughVirtualRegistersRegalloc);
    438     return NULL;
    439   }
    440 
    441   chunk->set_allocated_double_registers(
    442       allocator.assigned_double_registers());
    443 
    444   return chunk;
    445 }
    446 
    447 
    448 Handle<Code> LChunk::Codegen() {
    449   MacroAssembler assembler(info()->isolate(), NULL, 0,
    450                            CodeObjectRequired::kYes);
    451   // Code serializer only takes unoptimized code.
    452   DCHECK(!info()->will_serialize());
    453   LCodeGen generator(this, &assembler, info());
    454 
    455   MarkEmptyBlocks();
    456 
    457   if (generator.GenerateCode()) {
    458     generator.CheckEnvironmentUsage();
    459     CodeGenerator::MakeCodePrologue(info(), "optimized");
    460     Handle<Code> code = CodeGenerator::MakeCodeEpilogue(
    461         &assembler, nullptr, info(), assembler.CodeObject());
    462     generator.FinishCode(code);
    463     CommitDependencies(code);
    464     Handle<ByteArray> source_positions =
    465         generator.source_position_table_builder()->ToSourcePositionTable(
    466             info()->isolate(), Handle<AbstractCode>::cast(code));
    467     code->set_source_position_table(*source_positions);
    468     code->set_is_crankshafted(true);
    469 
    470     CodeGenerator::PrintCode(code, info());
    471     return code;
    472   }
    473   assembler.AbortedCodeGeneration();
    474   return Handle<Code>::null();
    475 }
    476 
    477 
    478 void LChunk::set_allocated_double_registers(BitVector* allocated_registers) {
    479   allocated_double_registers_ = allocated_registers;
    480   BitVector* doubles = allocated_double_registers();
    481   BitVector::Iterator iterator(doubles);
    482   while (!iterator.Done()) {
    483     if (info()->saves_caller_doubles()) {
    484       if (kDoubleSize == kPointerSize * 2) {
    485         current_frame_slots_ += 2;
    486       } else {
    487         current_frame_slots_++;
    488       }
    489     }
    490     iterator.Advance();
    491   }
    492 }
    493 
    494 
    495 void LChunkBuilderBase::Abort(BailoutReason reason) {
    496   info()->AbortOptimization(reason);
    497   status_ = ABORTED;
    498 }
    499 
    500 
    501 void LChunkBuilderBase::Retry(BailoutReason reason) {
    502   info()->RetryOptimization(reason);
    503   status_ = ABORTED;
    504 }
    505 
    506 void LChunkBuilderBase::CreateLazyBailoutForCall(HBasicBlock* current_block,
    507                                                  LInstruction* instr,
    508                                                  HInstruction* hydrogen_val) {
    509   if (!instr->IsCall()) return;
    510 
    511   HEnvironment* hydrogen_env = current_block->last_environment();
    512   HValue* hydrogen_value_for_lazy_bailout = hydrogen_val;
    513   DCHECK_NOT_NULL(hydrogen_env);
    514   if (instr->IsSyntacticTailCall()) {
    515     // If it was a syntactic tail call we need to drop the current frame and
    516     // all the frames on top of it that are either an arguments adaptor frame
    517     // or a tail caller frame.
    518     hydrogen_env = hydrogen_env->outer();
    519     while (hydrogen_env != nullptr &&
    520            (hydrogen_env->frame_type() == ARGUMENTS_ADAPTOR ||
    521             hydrogen_env->frame_type() == TAIL_CALLER_FUNCTION)) {
    522       hydrogen_env = hydrogen_env->outer();
    523     }
    524     if (hydrogen_env != nullptr) {
    525       if (hydrogen_env->frame_type() == JS_FUNCTION) {
    526         // In case an outer frame is a function frame we have to replay
    527         // environment manually because
    528         // 1) it does not contain a result of inlined function yet,
    529         // 2) we can't find the proper simulate that corresponds to the point
    530         //    after inlined call to do a ReplayEnvironment() on.
    531         // So we push return value on top of outer environment.
    532         // As for JS_GETTER/JS_SETTER/JS_CONSTRUCT nothing has to be done here,
    533         // the deoptimizer ensures that the result of the callee is correctly
    534         // propagated to result register during deoptimization.
    535         hydrogen_env = hydrogen_env->Copy();
    536         hydrogen_env->Push(hydrogen_val);
    537       }
    538     } else {
    539       // Although we don't need this lazy bailout for normal execution
    540       // (because when we tail call from the outermost function we should pop
    541       // its frame) we still need it when debugger is on.
    542       hydrogen_env = current_block->last_environment();
    543     }
    544   } else {
    545     if (hydrogen_val->HasObservableSideEffects()) {
    546       HSimulate* sim = HSimulate::cast(hydrogen_val->next());
    547       sim->ReplayEnvironment(hydrogen_env);
    548       hydrogen_value_for_lazy_bailout = sim;
    549     }
    550   }
    551   LInstruction* bailout = LChunkBuilderBase::AssignEnvironment(
    552       new (zone()) LLazyBailout(), hydrogen_env);
    553   bailout->set_hydrogen_value(hydrogen_value_for_lazy_bailout);
    554   chunk_->AddInstruction(bailout, current_block);
    555 }
    556 
    557 LInstruction* LChunkBuilderBase::AssignEnvironment(LInstruction* instr,
    558                                                    HEnvironment* hydrogen_env) {
    559   int argument_index_accumulator = 0;
    560   ZoneList<HValue*> objects_to_materialize(0, zone());
    561   DCHECK_NE(TAIL_CALLER_FUNCTION, hydrogen_env->frame_type());
    562   instr->set_environment(CreateEnvironment(
    563       hydrogen_env, &argument_index_accumulator, &objects_to_materialize));
    564   return instr;
    565 }
    566 
    567 LEnvironment* LChunkBuilderBase::CreateEnvironment(
    568     HEnvironment* hydrogen_env, int* argument_index_accumulator,
    569     ZoneList<HValue*>* objects_to_materialize) {
    570   if (hydrogen_env == NULL) return NULL;
    571 
    572   BailoutId ast_id = hydrogen_env->ast_id();
    573   DCHECK(!ast_id.IsNone() ||
    574          (hydrogen_env->frame_type() != JS_FUNCTION &&
    575           hydrogen_env->frame_type() != TAIL_CALLER_FUNCTION));
    576 
    577   if (hydrogen_env->frame_type() == TAIL_CALLER_FUNCTION) {
    578     // Skip potential outer arguments adaptor frame.
    579     HEnvironment* outer_hydrogen_env = hydrogen_env->outer();
    580     if (outer_hydrogen_env != nullptr &&
    581         outer_hydrogen_env->frame_type() == ARGUMENTS_ADAPTOR) {
    582       outer_hydrogen_env = outer_hydrogen_env->outer();
    583     }
    584     LEnvironment* outer = CreateEnvironment(
    585         outer_hydrogen_env, argument_index_accumulator, objects_to_materialize);
    586     return new (zone())
    587         LEnvironment(hydrogen_env->closure(), hydrogen_env->frame_type(),
    588                      ast_id, 0, 0, 0, outer, hydrogen_env->entry(), zone());
    589   }
    590 
    591   LEnvironment* outer =
    592       CreateEnvironment(hydrogen_env->outer(), argument_index_accumulator,
    593                         objects_to_materialize);
    594 
    595   int omitted_count = (hydrogen_env->frame_type() == JS_FUNCTION)
    596                           ? 0
    597                           : hydrogen_env->specials_count();
    598 
    599   int value_count = hydrogen_env->length() - omitted_count;
    600   LEnvironment* result =
    601       new(zone()) LEnvironment(hydrogen_env->closure(),
    602                                hydrogen_env->frame_type(),
    603                                ast_id,
    604                                hydrogen_env->parameter_count(),
    605                                argument_count_,
    606                                value_count,
    607                                outer,
    608                                hydrogen_env->entry(),
    609                                zone());
    610   int argument_index = *argument_index_accumulator;
    611 
    612   // Store the environment description into the environment
    613   // (with holes for nested objects)
    614   for (int i = 0; i < hydrogen_env->length(); ++i) {
    615     if (hydrogen_env->is_special_index(i) &&
    616         hydrogen_env->frame_type() != JS_FUNCTION) {
    617       continue;
    618     }
    619     LOperand* op;
    620     HValue* value = hydrogen_env->values()->at(i);
    621     CHECK(!value->IsPushArguments());  // Do not deopt outgoing arguments
    622     if (value->IsArgumentsObject() || value->IsCapturedObject()) {
    623       op = LEnvironment::materialization_marker();
    624     } else {
    625       op = UseAny(value);
    626     }
    627     result->AddValue(op,
    628                      value->representation(),
    629                      value->CheckFlag(HInstruction::kUint32));
    630   }
    631 
    632   // Recursively store the nested objects into the environment
    633   for (int i = 0; i < hydrogen_env->length(); ++i) {
    634     if (hydrogen_env->is_special_index(i)) continue;
    635 
    636     HValue* value = hydrogen_env->values()->at(i);
    637     if (value->IsArgumentsObject() || value->IsCapturedObject()) {
    638       AddObjectToMaterialize(value, objects_to_materialize, result);
    639     }
    640   }
    641 
    642   if (hydrogen_env->frame_type() == JS_FUNCTION) {
    643     *argument_index_accumulator = argument_index;
    644   }
    645 
    646   return result;
    647 }
    648 
    649 
    650 // Add an object to the supplied environment and object materialization list.
    651 //
    652 // Notes:
    653 //
    654 // We are building three lists here:
    655 //
    656 // 1. In the result->object_mapping_ list (added to by the
    657 //    LEnvironment::Add*Object methods), we store the lengths (number
    658 //    of fields) of the captured objects in depth-first traversal order, or
    659 //    in case of duplicated objects, we store the index to the duplicate object
    660 //    (with a tag to differentiate between captured and duplicated objects).
    661 //
    662 // 2. The object fields are stored in the result->values_ list
    663 //    (added to by the LEnvironment.AddValue method) sequentially as lists
    664 //    of fields with holes for nested objects (the holes will be expanded
    665 //    later by LCodegen::AddToTranslation according to the
    666 //    LEnvironment.object_mapping_ list).
    667 //
    668 // 3. The auxiliary objects_to_materialize array stores the hydrogen values
    669 //    in the same order as result->object_mapping_ list. This is used
    670 //    to detect duplicate values and calculate the corresponding object index.
    671 void LChunkBuilderBase::AddObjectToMaterialize(HValue* value,
    672     ZoneList<HValue*>* objects_to_materialize, LEnvironment* result) {
    673   int object_index = objects_to_materialize->length();
    674   // Store the hydrogen value into the de-duplication array
    675   objects_to_materialize->Add(value, zone());
    676   // Find out whether we are storing a duplicated value
    677   int previously_materialized_object = -1;
    678   for (int prev = 0; prev < object_index; ++prev) {
    679     if (objects_to_materialize->at(prev) == value) {
    680       previously_materialized_object = prev;
    681       break;
    682     }
    683   }
    684   // Store the captured object length (or duplicated object index)
    685   // into the environment. For duplicated objects, we stop here.
    686   int length = value->OperandCount();
    687   bool is_arguments = value->IsArgumentsObject();
    688   if (previously_materialized_object >= 0) {
    689     result->AddDuplicateObject(previously_materialized_object);
    690     return;
    691   } else {
    692     result->AddNewObject(is_arguments ? length - 1 : length, is_arguments);
    693   }
    694   // Store the captured object's fields into the environment
    695   for (int i = is_arguments ? 1 : 0; i < length; ++i) {
    696     LOperand* op;
    697     HValue* arg_value = value->OperandAt(i);
    698     if (arg_value->IsArgumentsObject() || arg_value->IsCapturedObject()) {
    699       // Insert a hole for nested objects
    700       op = LEnvironment::materialization_marker();
    701     } else {
    702       DCHECK(!arg_value->IsPushArguments());
    703       // For ordinary values, tell the register allocator we need the value
    704       // to be alive here
    705       op = UseAny(arg_value);
    706     }
    707     result->AddValue(op,
    708                      arg_value->representation(),
    709                      arg_value->CheckFlag(HInstruction::kUint32));
    710   }
    711   // Recursively store all the nested captured objects into the environment
    712   for (int i = is_arguments ? 1 : 0; i < length; ++i) {
    713     HValue* arg_value = value->OperandAt(i);
    714     if (arg_value->IsArgumentsObject() || arg_value->IsCapturedObject()) {
    715       AddObjectToMaterialize(arg_value, objects_to_materialize, result);
    716     }
    717   }
    718 }
    719 
    720 
    721 LPhase::~LPhase() {
    722   if (ShouldProduceTraceOutput()) {
    723     isolate()->GetHTracer()->TraceLithium(name(), chunk_);
    724   }
    725 }
    726 
    727 
    728 }  // namespace internal
    729 }  // namespace v8
    730