Home | History | Annotate | Download | only in compiler 
      1 // Copyright 2013 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/compiler/code-generator.h"
      6 
      7 #include "src/compiler/code-generator-impl.h"
      8 #include "src/compiler/linkage.h"
      9 #include "src/compiler/pipeline.h"
     10 
     11 namespace v8 {
     12 namespace internal {
     13 namespace compiler {
     14 
     15 CodeGenerator::CodeGenerator(InstructionSequence* code)
     16     : code_(code),
     17       current_block_(NULL),
     18       current_source_position_(SourcePosition::Invalid()),
     19       masm_(code->zone()->isolate(), NULL, 0),
     20       resolver_(this),
     21       safepoints_(code->zone()),
     22       deoptimization_states_(code->zone()),
     23       deoptimization_literals_(code->zone()),
     24       translations_(code->zone()),
     25       last_lazy_deopt_pc_(0) {}
     26 
     27 
     28 Handle<Code> CodeGenerator::GenerateCode() {
     29   CompilationInfo* info = linkage()->info();
     30 
     31   // Emit a code line info recording start event.
     32   PositionsRecorder* recorder = masm()->positions_recorder();
     33   LOG_CODE_EVENT(isolate(), CodeStartLinePosInfoRecordEvent(recorder));
     34 
     35   // Place function entry hook if requested to do so.
     36   if (linkage()->GetIncomingDescriptor()->IsJSFunctionCall()) {
     37     ProfileEntryHookStub::MaybeCallEntryHook(masm());
     38   }
     39 
     40   // Architecture-specific, linkage-specific prologue.
     41   info->set_prologue_offset(masm()->pc_offset());
     42   AssemblePrologue();
     43 
     44   // Assemble all instructions.
     45   for (InstructionSequence::const_iterator i = code()->begin();
     46        i != code()->end(); ++i) {
     47     AssembleInstruction(*i);
     48   }
     49 
     50   FinishCode(masm());
     51 
     52   // Ensure there is space for lazy deopt.
     53   if (!info->IsStub()) {
     54     int target_offset = masm()->pc_offset() + Deoptimizer::patch_size();
     55     while (masm()->pc_offset() < target_offset) {
     56       masm()->nop();
     57     }
     58   }
     59 
     60   safepoints()->Emit(masm(), frame()->GetSpillSlotCount());
     61 
     62   // TODO(titzer): what are the right code flags here?
     63   Code::Kind kind = Code::STUB;
     64   if (linkage()->GetIncomingDescriptor()->IsJSFunctionCall()) {
     65     kind = Code::OPTIMIZED_FUNCTION;
     66   }
     67   Handle<Code> result = v8::internal::CodeGenerator::MakeCodeEpilogue(
     68       masm(), Code::ComputeFlags(kind), info);
     69   result->set_is_turbofanned(true);
     70   result->set_stack_slots(frame()->GetSpillSlotCount());
     71   result->set_safepoint_table_offset(safepoints()->GetCodeOffset());
     72 
     73   PopulateDeoptimizationData(result);
     74 
     75   // Emit a code line info recording stop event.
     76   void* line_info = recorder->DetachJITHandlerData();
     77   LOG_CODE_EVENT(isolate(), CodeEndLinePosInfoRecordEvent(*result, line_info));
     78 
     79   return result;
     80 }
     81 
     82 
     83 void CodeGenerator::RecordSafepoint(PointerMap* pointers, Safepoint::Kind kind,
     84                                     int arguments,
     85                                     Safepoint::DeoptMode deopt_mode) {
     86   const ZoneList<InstructionOperand*>* operands =
     87       pointers->GetNormalizedOperands();
     88   Safepoint safepoint =
     89       safepoints()->DefineSafepoint(masm(), kind, arguments, deopt_mode);
     90   for (int i = 0; i < operands->length(); i++) {
     91     InstructionOperand* pointer = operands->at(i);
     92     if (pointer->IsStackSlot()) {
     93       safepoint.DefinePointerSlot(pointer->index(), zone());
     94     } else if (pointer->IsRegister() && (kind & Safepoint::kWithRegisters)) {
     95       Register reg = Register::FromAllocationIndex(pointer->index());
     96       safepoint.DefinePointerRegister(reg, zone());
     97     }
     98   }
     99 }
    100 
    101 
    102 void CodeGenerator::AssembleInstruction(Instruction* instr) {
    103   if (instr->IsBlockStart()) {
    104     // Bind a label for a block start and handle parallel moves.
    105     BlockStartInstruction* block_start = BlockStartInstruction::cast(instr);
    106     current_block_ = block_start->block();
    107     if (FLAG_code_comments) {
    108       // TODO(titzer): these code comments are a giant memory leak.
    109       Vector<char> buffer = Vector<char>::New(32);
    110       SNPrintF(buffer, "-- B%d start --", block_start->block()->id());
    111       masm()->RecordComment(buffer.start());
    112     }
    113     masm()->bind(block_start->label());
    114   }
    115   if (instr->IsGapMoves()) {
    116     // Handle parallel moves associated with the gap instruction.
    117     AssembleGap(GapInstruction::cast(instr));
    118   } else if (instr->IsSourcePosition()) {
    119     AssembleSourcePosition(SourcePositionInstruction::cast(instr));
    120   } else {
    121     // Assemble architecture-specific code for the instruction.
    122     AssembleArchInstruction(instr);
    123 
    124     // Assemble branches or boolean materializations after this instruction.
    125     FlagsMode mode = FlagsModeField::decode(instr->opcode());
    126     FlagsCondition condition = FlagsConditionField::decode(instr->opcode());
    127     switch (mode) {
    128       case kFlags_none:
    129         return;
    130       case kFlags_set:
    131         return AssembleArchBoolean(instr, condition);
    132       case kFlags_branch:
    133         return AssembleArchBranch(instr, condition);
    134     }
    135     UNREACHABLE();
    136   }
    137 }
    138 
    139 
    140 void CodeGenerator::AssembleSourcePosition(SourcePositionInstruction* instr) {
    141   SourcePosition source_position = instr->source_position();
    142   if (source_position == current_source_position_) return;
    143   DCHECK(!source_position.IsInvalid());
    144   if (!source_position.IsUnknown()) {
    145     int code_pos = source_position.raw();
    146     masm()->positions_recorder()->RecordPosition(source_position.raw());
    147     masm()->positions_recorder()->WriteRecordedPositions();
    148     if (FLAG_code_comments) {
    149       Vector<char> buffer = Vector<char>::New(256);
    150       CompilationInfo* info = linkage()->info();
    151       int ln = Script::GetLineNumber(info->script(), code_pos);
    152       int cn = Script::GetColumnNumber(info->script(), code_pos);
    153       if (info->script()->name()->IsString()) {
    154         Handle<String> file(String::cast(info->script()->name()));
    155         base::OS::SNPrintF(buffer.start(), buffer.length(), "-- %s:%d:%d --",
    156                            file->ToCString().get(), ln, cn);
    157       } else {
    158         base::OS::SNPrintF(buffer.start(), buffer.length(),
    159                            "-- <unknown>:%d:%d --", ln, cn);
    160       }
    161       masm()->RecordComment(buffer.start());
    162     }
    163   }
    164   current_source_position_ = source_position;
    165 }
    166 
    167 
    168 void CodeGenerator::AssembleGap(GapInstruction* instr) {
    169   for (int i = GapInstruction::FIRST_INNER_POSITION;
    170        i <= GapInstruction::LAST_INNER_POSITION; i++) {
    171     GapInstruction::InnerPosition inner_pos =
    172         static_cast<GapInstruction::InnerPosition>(i);
    173     ParallelMove* move = instr->GetParallelMove(inner_pos);
    174     if (move != NULL) resolver()->Resolve(move);
    175   }
    176 }
    177 
    178 
    179 void CodeGenerator::PopulateDeoptimizationData(Handle<Code> code_object) {
    180   CompilationInfo* info = linkage()->info();
    181   int deopt_count = static_cast<int>(deoptimization_states_.size());
    182   if (deopt_count == 0) return;
    183   Handle<DeoptimizationInputData> data =
    184       DeoptimizationInputData::New(isolate(), deopt_count, TENURED);
    185 
    186   Handle<ByteArray> translation_array =
    187       translations_.CreateByteArray(isolate()->factory());
    188 
    189   data->SetTranslationByteArray(*translation_array);
    190   data->SetInlinedFunctionCount(Smi::FromInt(0));
    191   data->SetOptimizationId(Smi::FromInt(info->optimization_id()));
    192   // TODO(jarin) The following code was copied over from Lithium, not sure
    193   // whether the scope or the IsOptimizing condition are really needed.
    194   if (info->IsOptimizing()) {
    195     // Reference to shared function info does not change between phases.
    196     AllowDeferredHandleDereference allow_handle_dereference;
    197     data->SetSharedFunctionInfo(*info->shared_info());
    198   } else {
    199     data->SetSharedFunctionInfo(Smi::FromInt(0));
    200   }
    201 
    202   Handle<FixedArray> literals = isolate()->factory()->NewFixedArray(
    203       static_cast<int>(deoptimization_literals_.size()), TENURED);
    204   {
    205     AllowDeferredHandleDereference copy_handles;
    206     for (unsigned i = 0; i < deoptimization_literals_.size(); i++) {
    207       literals->set(i, *deoptimization_literals_[i]);
    208     }
    209     data->SetLiteralArray(*literals);
    210   }
    211 
    212   // No OSR in Turbofan yet...
    213   BailoutId osr_ast_id = BailoutId::None();
    214   data->SetOsrAstId(Smi::FromInt(osr_ast_id.ToInt()));
    215   data->SetOsrPcOffset(Smi::FromInt(-1));
    216 
    217   // Populate deoptimization entries.
    218   for (int i = 0; i < deopt_count; i++) {
    219     DeoptimizationState* deoptimization_state = deoptimization_states_[i];
    220     data->SetAstId(i, deoptimization_state->bailout_id());
    221     CHECK_NE(NULL, deoptimization_states_[i]);
    222     data->SetTranslationIndex(
    223         i, Smi::FromInt(deoptimization_states_[i]->translation_id()));
    224     data->SetArgumentsStackHeight(i, Smi::FromInt(0));
    225     data->SetPc(i, Smi::FromInt(deoptimization_state->pc_offset()));
    226   }
    227 
    228   code_object->set_deoptimization_data(*data);
    229 }
    230 
    231 
    232 void CodeGenerator::AddSafepointAndDeopt(Instruction* instr) {
    233   CallDescriptor::Flags flags(MiscField::decode(instr->opcode()));
    234 
    235   bool needs_frame_state = (flags & CallDescriptor::kNeedsFrameState);
    236 
    237   RecordSafepoint(
    238       instr->pointer_map(), Safepoint::kSimple, 0,
    239       needs_frame_state ? Safepoint::kLazyDeopt : Safepoint::kNoLazyDeopt);
    240 
    241   if (flags & CallDescriptor::kNeedsNopAfterCall) {
    242     AddNopForSmiCodeInlining();
    243   }
    244 
    245   if (needs_frame_state) {
    246     MarkLazyDeoptSite();
    247     // If the frame state is present, it starts at argument 1
    248     // (just after the code address).
    249     InstructionOperandConverter converter(this, instr);
    250     // Deoptimization info starts at argument 1
    251     size_t frame_state_offset = 1;
    252     FrameStateDescriptor* descriptor =
    253         GetFrameStateDescriptor(instr, frame_state_offset);
    254     int pc_offset = masm()->pc_offset();
    255     int deopt_state_id = BuildTranslation(instr, pc_offset, frame_state_offset,
    256                                           descriptor->state_combine());
    257     // If the pre-call frame state differs from the post-call one, produce the
    258     // pre-call frame state, too.
    259     // TODO(jarin) We might want to avoid building the pre-call frame state
    260     // because it is only used to get locals and arguments (by the debugger and
    261     // f.arguments), and those are the same in the pre-call and post-call
    262     // states.
    263     if (descriptor->state_combine() != kIgnoreOutput) {
    264       deopt_state_id =
    265           BuildTranslation(instr, -1, frame_state_offset, kIgnoreOutput);
    266     }
    267 #if DEBUG
    268     // Make sure all the values live in stack slots or they are immediates.
    269     // (The values should not live in register because registers are clobbered
    270     // by calls.)
    271     for (size_t i = 0; i < descriptor->size(); i++) {
    272       InstructionOperand* op = instr->InputAt(frame_state_offset + 1 + i);
    273       CHECK(op->IsStackSlot() || op->IsImmediate());
    274     }
    275 #endif
    276     safepoints()->RecordLazyDeoptimizationIndex(deopt_state_id);
    277   }
    278 }
    279 
    280 
    281 int CodeGenerator::DefineDeoptimizationLiteral(Handle<Object> literal) {
    282   int result = static_cast<int>(deoptimization_literals_.size());
    283   for (unsigned i = 0; i < deoptimization_literals_.size(); ++i) {
    284     if (deoptimization_literals_[i].is_identical_to(literal)) return i;
    285   }
    286   deoptimization_literals_.push_back(literal);
    287   return result;
    288 }
    289 
    290 
    291 FrameStateDescriptor* CodeGenerator::GetFrameStateDescriptor(
    292     Instruction* instr, size_t frame_state_offset) {
    293   InstructionOperandConverter i(this, instr);
    294   InstructionSequence::StateId state_id = InstructionSequence::StateId::FromInt(
    295       i.InputInt32(static_cast<int>(frame_state_offset)));
    296   return code()->GetFrameStateDescriptor(state_id);
    297 }
    298 
    299 
    300 void CodeGenerator::BuildTranslationForFrameStateDescriptor(
    301     FrameStateDescriptor* descriptor, Instruction* instr,
    302     Translation* translation, size_t frame_state_offset,
    303     OutputFrameStateCombine state_combine) {
    304   // Outer-most state must be added to translation first.
    305   if (descriptor->outer_state() != NULL) {
    306     BuildTranslationForFrameStateDescriptor(descriptor->outer_state(), instr,
    307                                             translation, frame_state_offset,
    308                                             kIgnoreOutput);
    309   }
    310 
    311   int id = Translation::kSelfLiteralId;
    312   if (!descriptor->jsfunction().is_null()) {
    313     id = DefineDeoptimizationLiteral(
    314         Handle<Object>::cast(descriptor->jsfunction().ToHandleChecked()));
    315   }
    316 
    317   switch (descriptor->type()) {
    318     case JS_FRAME:
    319       translation->BeginJSFrame(
    320           descriptor->bailout_id(), id,
    321           static_cast<unsigned int>(descriptor->GetHeight(state_combine)));
    322       break;
    323     case ARGUMENTS_ADAPTOR:
    324       translation->BeginArgumentsAdaptorFrame(
    325           id, static_cast<unsigned int>(descriptor->parameters_count()));
    326       break;
    327   }
    328 
    329   frame_state_offset += descriptor->outer_state()->GetTotalSize();
    330   for (size_t i = 0; i < descriptor->size(); i++) {
    331     AddTranslationForOperand(
    332         translation, instr,
    333         instr->InputAt(static_cast<int>(frame_state_offset + i)));
    334   }
    335 
    336   switch (state_combine) {
    337     case kPushOutput:
    338       DCHECK(instr->OutputCount() == 1);
    339       AddTranslationForOperand(translation, instr, instr->OutputAt(0));
    340       break;
    341     case kIgnoreOutput:
    342       break;
    343   }
    344 }
    345 
    346 
    347 int CodeGenerator::BuildTranslation(Instruction* instr, int pc_offset,
    348                                     size_t frame_state_offset,
    349                                     OutputFrameStateCombine state_combine) {
    350   FrameStateDescriptor* descriptor =
    351       GetFrameStateDescriptor(instr, frame_state_offset);
    352   frame_state_offset++;
    353 
    354   Translation translation(
    355       &translations_, static_cast<int>(descriptor->GetFrameCount()),
    356       static_cast<int>(descriptor->GetJSFrameCount()), zone());
    357   BuildTranslationForFrameStateDescriptor(descriptor, instr, &translation,
    358                                           frame_state_offset, state_combine);
    359 
    360   int deoptimization_id = static_cast<int>(deoptimization_states_.size());
    361 
    362   deoptimization_states_.push_back(new (zone()) DeoptimizationState(
    363       descriptor->bailout_id(), translation.index(), pc_offset));
    364 
    365   return deoptimization_id;
    366 }
    367 
    368 
    369 void CodeGenerator::AddTranslationForOperand(Translation* translation,
    370                                              Instruction* instr,
    371                                              InstructionOperand* op) {
    372   if (op->IsStackSlot()) {
    373     translation->StoreStackSlot(op->index());
    374   } else if (op->IsDoubleStackSlot()) {
    375     translation->StoreDoubleStackSlot(op->index());
    376   } else if (op->IsRegister()) {
    377     InstructionOperandConverter converter(this, instr);
    378     translation->StoreRegister(converter.ToRegister(op));
    379   } else if (op->IsDoubleRegister()) {
    380     InstructionOperandConverter converter(this, instr);
    381     translation->StoreDoubleRegister(converter.ToDoubleRegister(op));
    382   } else if (op->IsImmediate()) {
    383     InstructionOperandConverter converter(this, instr);
    384     Constant constant = converter.ToConstant(op);
    385     Handle<Object> constant_object;
    386     switch (constant.type()) {
    387       case Constant::kInt32:
    388         constant_object =
    389             isolate()->factory()->NewNumberFromInt(constant.ToInt32());
    390         break;
    391       case Constant::kFloat64:
    392         constant_object = isolate()->factory()->NewNumber(constant.ToFloat64());
    393         break;
    394       case Constant::kHeapObject:
    395         constant_object = constant.ToHeapObject();
    396         break;
    397       default:
    398         UNREACHABLE();
    399     }
    400     int literal_id = DefineDeoptimizationLiteral(constant_object);
    401     translation->StoreLiteral(literal_id);
    402   } else {
    403     UNREACHABLE();
    404   }
    405 }
    406 
    407 
    408 void CodeGenerator::MarkLazyDeoptSite() {
    409   last_lazy_deopt_pc_ = masm()->pc_offset();
    410 }
    411 
    412 #if !V8_TURBOFAN_BACKEND
    413 
    414 void CodeGenerator::AssembleArchInstruction(Instruction* instr) {
    415   UNIMPLEMENTED();
    416 }
    417 
    418 
    419 void CodeGenerator::AssembleArchBranch(Instruction* instr,
    420                                        FlagsCondition condition) {
    421   UNIMPLEMENTED();
    422 }
    423 
    424 
    425 void CodeGenerator::AssembleArchBoolean(Instruction* instr,
    426                                         FlagsCondition condition) {
    427   UNIMPLEMENTED();
    428 }
    429 
    430 
    431 void CodeGenerator::AssembleDeoptimizerCall(int deoptimization_id) {
    432   UNIMPLEMENTED();
    433 }
    434 
    435 
    436 void CodeGenerator::AssemblePrologue() { UNIMPLEMENTED(); }
    437 
    438 
    439 void CodeGenerator::AssembleReturn() { UNIMPLEMENTED(); }
    440 
    441 
    442 void CodeGenerator::AssembleMove(InstructionOperand* source,
    443                                  InstructionOperand* destination) {
    444   UNIMPLEMENTED();
    445 }
    446 
    447 
    448 void CodeGenerator::AssembleSwap(InstructionOperand* source,
    449                                  InstructionOperand* destination) {
    450   UNIMPLEMENTED();
    451 }
    452 
    453 
    454 void CodeGenerator::AddNopForSmiCodeInlining() { UNIMPLEMENTED(); }
    455 
    456 #endif  // !V8_TURBOFAN_BACKEND
    457 
    458 }  // namespace compiler
    459 }  // namespace internal
    460 }  // namespace v8
    461