src/v8/src/mips/lithium-codegen-mips.cc

   1 // Copyright 2012 the V8 project authors. All rights reserved.7
   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 "src/v8.h"
  29
  30 #include "src/mips/lithium-codegen-mips.h"
  31 #include "src/mips/lithium-gap-resolver-mips.h"
  32 #include "src/code-stubs.h"
  33 #include "src/stub-cache.h"
  34 #include "src/hydrogen-osr.h"
  35
  36 namespace v8 {
  37 namespace internal {
  38
  39
  40 class SafepointGenerator V8_FINAL  : public CallWrapper {
  41  public:
  42   SafepointGenerator(LCodeGen* codegen,
  43                      LPointerMap* pointers,
  44                      Safepoint::DeoptMode mode)
  45       : codegen_(codegen),
  46         pointers_(pointers),
  47         deopt_mode_(mode) { }
  48   virtual ~SafepointGenerator() {}
  49
  50   virtual void BeforeCall(int call_size) const V8_OVERRIDE {}
  51
  52   virtual void AfterCall() const V8_OVERRIDE {
  53     codegen_->RecordSafepoint(pointers_, deopt_mode_);
  54   }
  55
  56  private:
  57   LCodeGen* codegen_;
  58   LPointerMap* pointers_;
  59   Safepoint::DeoptMode deopt_mode_;
  60 };
  61
  62
  63 #define __ masm()->
  64
  65 bool LCodeGen::GenerateCode() {
  66   LPhase phase("Z_Code generation", chunk());
  67   ASSERT(is_unused());
  68   status_ = GENERATING;
  69
  70   // Open a frame scope to indicate that there is a frame on the stack.  The
  71   // NONE indicates that the scope shouldn't actually generate code to set up
  72   // the frame (that is done in GeneratePrologue).
  73   FrameScope frame_scope(masm_, StackFrame::NONE);
  74
  75   return GeneratePrologue() &&
  76       GenerateBody() &&
  77       GenerateDeferredCode() &&
  78       GenerateDeoptJumpTable() &&
  79       GenerateSafepointTable();
  80 }
  81
  82
  83 void LCodeGen::FinishCode(Handle<Code> code) {
  84   ASSERT(is_done());
  85   code->set_stack_slots(GetStackSlotCount());
  86   code->set_safepoint_table_offset(safepoints_.GetCodeOffset());
  87   if (code->is_optimized_code()) RegisterWeakObjectsInOptimizedCode(code);
  88   PopulateDeoptimizationData(code);
  89 }
  90
  91
  92 void LCodeGen::SaveCallerDoubles() {
  93   ASSERT(info()->saves_caller_doubles());
  94   ASSERT(NeedsEagerFrame());
  95   Comment(";;; Save clobbered callee double registers");
  96   int count = 0;
  97   BitVector* doubles = chunk()->allocated_double_registers();
  98   BitVector::Iterator save_iterator(doubles);
  99   while (!save_iterator.Done()) {
 100     __ sdc1(DoubleRegister::FromAllocationIndex(save_iterator.Current()),
 101             MemOperand(sp, count * kDoubleSize));
 102     save_iterator.Advance();
 103     count++;
 104   }
 105 }
 106
 107
 108 void LCodeGen::RestoreCallerDoubles() {
 109   ASSERT(info()->saves_caller_doubles());
 110   ASSERT(NeedsEagerFrame());
 111   Comment(";;; Restore clobbered callee double registers");
 112   BitVector* doubles = chunk()->allocated_double_registers();
 113   BitVector::Iterator save_iterator(doubles);
 114   int count = 0;
 115   while (!save_iterator.Done()) {
 116     __ ldc1(DoubleRegister::FromAllocationIndex(save_iterator.Current()),
 117             MemOperand(sp, count * kDoubleSize));
 118     save_iterator.Advance();
 119     count++;
 120   }
 121 }
 122
 123
 124 bool LCodeGen::GeneratePrologue() {
 125   ASSERT(is_generating());
 126
 127   if (info()->IsOptimizing()) {
 128     ProfileEntryHookStub::MaybeCallEntryHook(masm_);
 129
 130 #ifdef DEBUG
 131     if (strlen(FLAG_stop_at) > 0 &&
 132         info_->function()->name()->IsUtf8EqualTo(CStrVector(FLAG_stop_at))) {
 133       __ stop("stop_at");
 134     }
 135 #endif
 136
 137     // a1: Callee's JS function.
 138     // cp: Callee's context.
 139     // fp: Caller's frame pointer.
 140     // lr: Caller's pc.
 141
 142     // Sloppy mode functions and builtins need to replace the receiver with the
 143     // global proxy when called as functions (without an explicit receiver
 144     // object).
 145     if (info_->this_has_uses() &&
 146         info_->strict_mode() == SLOPPY &&
 147         !info_->is_native()) {
 148       Label ok;
 149       int receiver_offset = info_->scope()->num_parameters() * kPointerSize;
 150       __ LoadRoot(at, Heap::kUndefinedValueRootIndex);
 151       __ lw(a2, MemOperand(sp, receiver_offset));
 152       __ Branch(&ok, ne, a2, Operand(at));
 153
 154       __ lw(a2, GlobalObjectOperand());
 155       __ lw(a2, FieldMemOperand(a2, GlobalObject::kGlobalReceiverOffset));
 156
 157       __ sw(a2, MemOperand(sp, receiver_offset));
 158
 159       __ bind(&ok);
 160     }
 161   }
 162
 163   info()->set_prologue_offset(masm_->pc_offset());
 164   if (NeedsEagerFrame()) {
 165     if (info()->IsStub()) {
 166       __ StubPrologue();
 167     } else {
 168       __ Prologue(info()->IsCodePreAgingActive());
 169     }
 170     frame_is_built_ = true;
 171     info_->AddNoFrameRange(0, masm_->pc_offset());
 172   }
 173
 174   // Reserve space for the stack slots needed by the code.
 175   int slots = GetStackSlotCount();
 176   if (slots > 0) {
 177     if (FLAG_debug_code) {
 178       __ Subu(sp,  sp, Operand(slots * kPointerSize));
 179       __ Push(a0, a1);
 180       __ Addu(a0, sp, Operand(slots *  kPointerSize));
 181       __ li(a1, Operand(kSlotsZapValue));
 182       Label loop;
 183       __ bind(&loop);
 184       __ Subu(a0, a0, Operand(kPointerSize));
 185       __ sw(a1, MemOperand(a0, 2 * kPointerSize));
 186       __ Branch(&loop, ne, a0, Operand(sp));
 187       __ Pop(a0, a1);
 188     } else {
 189       __ Subu(sp, sp, Operand(slots * kPointerSize));
 190     }
 191   }
 192
 193   if (info()->saves_caller_doubles()) {
 194     SaveCallerDoubles();
 195   }
 196
 197   // Possibly allocate a local context.
 198   int heap_slots = info()->num_heap_slots() - Context::MIN_CONTEXT_SLOTS;
 199   if (heap_slots > 0) {
 200     Comment(";;; Allocate local context");
 201     bool need_write_barrier = true;
 202     // Argument to NewContext is the function, which is in a1.
 203     if (heap_slots <= FastNewContextStub::kMaximumSlots) {
 204       FastNewContextStub stub(isolate(), heap_slots);
 205       __ CallStub(&stub);
 206       // Result of FastNewContextStub is always in new space.
 207       need_write_barrier = false;
 208     } else {
 209       __ push(a1);
 210       __ CallRuntime(Runtime::kHiddenNewFunctionContext, 1);
 211     }
 212     RecordSafepoint(Safepoint::kNoLazyDeopt);
 213     // Context is returned in both v0. It replaces the context passed to us.
 214     // It's saved in the stack and kept live in cp.
 215     __ mov(cp, v0);
 216     __ sw(v0, MemOperand(fp, StandardFrameConstants::kContextOffset));
 217     // Copy any necessary parameters into the context.
 218     int num_parameters = scope()->num_parameters();
 219     for (int i = 0; i < num_parameters; i++) {
 220       Variable* var = scope()->parameter(i);
 221       if (var->IsContextSlot()) {
 222         int parameter_offset = StandardFrameConstants::kCallerSPOffset +
 223             (num_parameters - 1 - i) * kPointerSize;
 224         // Load parameter from stack.
 225         __ lw(a0, MemOperand(fp, parameter_offset));
 226         // Store it in the context.
 227         MemOperand target = ContextOperand(cp, var->index());
 228         __ sw(a0, target);
 229         // Update the write barrier. This clobbers a3 and a0.
 230         if (need_write_barrier) {
 231           __ RecordWriteContextSlot(
 232               cp, target.offset(), a0, a3, GetRAState(), kSaveFPRegs);
 233         } else if (FLAG_debug_code) {
 234           Label done;
 235           __ JumpIfInNewSpace(cp, a0, &done);
 236           __ Abort(kExpectedNewSpaceObject);
 237           __ bind(&done);
 238         }
 239       }
 240     }
 241     Comment(";;; End allocate local context");
 242   }
 243
 244   // Trace the call.
 245   if (FLAG_trace && info()->IsOptimizing()) {
 246     // We have not executed any compiled code yet, so cp still holds the
 247     // incoming context.
 248     __ CallRuntime(Runtime::kTraceEnter, 0);
 249   }
 250   return !is_aborted();
 251 }
 252
 253
 254 void LCodeGen::GenerateOsrPrologue() {
 255   // Generate the OSR entry prologue at the first unknown OSR value, or if there
 256   // are none, at the OSR entrypoint instruction.
 257   if (osr_pc_offset_ >= 0) return;
 258
 259   osr_pc_offset_ = masm()->pc_offset();
 260
 261   // Adjust the frame size, subsuming the unoptimized frame into the
 262   // optimized frame.
 263   int slots = GetStackSlotCount() - graph()->osr()->UnoptimizedFrameSlots();
 264   ASSERT(slots >= 0);
 265   __ Subu(sp, sp, Operand(slots * kPointerSize));
 266 }
 267
 268
 269 void LCodeGen::GenerateBodyInstructionPre(LInstruction* instr) {
 270   if (instr->IsCall()) {
 271     EnsureSpaceForLazyDeopt(Deoptimizer::patch_size());
 272   }
 273   if (!instr->IsLazyBailout() && !instr->IsGap()) {
 274     safepoints_.BumpLastLazySafepointIndex();
 275   }
 276 }
 277
 278
 279 bool LCodeGen::GenerateDeferredCode() {
 280   ASSERT(is_generating());
 281   if (deferred_.length() > 0) {
 282     for (int i = 0; !is_aborted() && i < deferred_.length(); i++) {
 283       LDeferredCode* code = deferred_[i];
 284
 285       HValue* value =
 286           instructions_->at(code->instruction_index())->hydrogen_value();
 287       RecordAndWritePosition(
 288           chunk()->graph()->SourcePositionToScriptPosition(value->position()));
 289
 290       Comment(";;; <@%d,#%d> "
 291               "-------------------- Deferred %s --------------------",
 292               code->instruction_index(),
 293               code->instr()->hydrogen_value()->id(),
 294               code->instr()->Mnemonic());
 295       __ bind(code->entry());
 296       if (NeedsDeferredFrame()) {
 297         Comment(";;; Build frame");
 298         ASSERT(!frame_is_built_);
 299         ASSERT(info()->IsStub());
 300         frame_is_built_ = true;
 301         __ MultiPush(cp.bit() | fp.bit() | ra.bit());
 302         __ li(scratch0(), Operand(Smi::FromInt(StackFrame::STUB)));
 303         __ push(scratch0());
 304         __ Addu(fp, sp, Operand(StandardFrameConstants::kFixedFrameSizeFromFp));
 305         Comment(";;; Deferred code");
 306       }
 307       code->Generate();
 308       if (NeedsDeferredFrame()) {
 309         Comment(";;; Destroy frame");
 310         ASSERT(frame_is_built_);
 311         __ pop(at);
 312         __ MultiPop(cp.bit() | fp.bit() | ra.bit());
 313         frame_is_built_ = false;
 314       }
 315       __ jmp(code->exit());
 316     }
 317   }
 318   // Deferred code is the last part of the instruction sequence. Mark
 319   // the generated code as done unless we bailed out.
 320   if (!is_aborted()) status_ = DONE;
 321   return !is_aborted();
 322 }
 323
 324
 325 bool LCodeGen::GenerateDeoptJumpTable() {
 326   if (deopt_jump_table_.length() > 0) {
 327     Comment(";;; -------------------- Jump table --------------------");
 328   }
 329   Assembler::BlockTrampolinePoolScope block_trampoline_pool(masm_);
 330   Label table_start;
 331   __ bind(&table_start);
 332   Label needs_frame;
 333   for (int i = 0; i < deopt_jump_table_.length(); i++) {
 334     __ bind(&deopt_jump_table_[i].label);
 335     Address entry = deopt_jump_table_[i].address;
 336     Deoptimizer::BailoutType type = deopt_jump_table_[i].bailout_type;
 337     int id = Deoptimizer::GetDeoptimizationId(isolate(), entry, type);
 338     if (id == Deoptimizer::kNotDeoptimizationEntry) {
 339       Comment(";;; jump table entry %d.", i);
 340     } else {
 341       Comment(";;; jump table entry %d: deoptimization bailout %d.", i, id);
 342     }
 343     __ li(t9, Operand(ExternalReference::ForDeoptEntry(entry)));
 344     if (deopt_jump_table_[i].needs_frame) {
 345       ASSERT(!info()->saves_caller_doubles());
 346       if (needs_frame.is_bound()) {
 347         __ Branch(&needs_frame);
 348       } else {
 349         __ bind(&needs_frame);
 350         __ MultiPush(cp.bit() | fp.bit() | ra.bit());
 351         // This variant of deopt can only be used with stubs. Since we don't
 352         // have a function pointer to install in the stack frame that we're
 353         // building, install a special marker there instead.
 354         ASSERT(info()->IsStub());
 355         __ li(scratch0(), Operand(Smi::FromInt(StackFrame::STUB)));
 356         __ push(scratch0());
 357         __ Addu(fp, sp, Operand(StandardFrameConstants::kFixedFrameSizeFromFp));
 358         __ Call(t9);
 359       }
 360     } else {
 361       if (info()->saves_caller_doubles()) {
 362         ASSERT(info()->IsStub());
 363         RestoreCallerDoubles();
 364       }
 365       __ Call(t9);
 366     }
 367   }
 368   __ RecordComment("]");
 369
 370   // The deoptimization jump table is the last part of the instruction
 371   // sequence. Mark the generated code as done unless we bailed out.
 372   if (!is_aborted()) status_ = DONE;
 373   return !is_aborted();
 374 }
 375
 376
 377 bool LCodeGen::GenerateSafepointTable() {
 378   ASSERT(is_done());
 379   safepoints_.Emit(masm(), GetStackSlotCount());
 380   return !is_aborted();
 381 }
 382
 383
 384 Register LCodeGen::ToRegister(int index) const {
 385   return Register::FromAllocationIndex(index);
 386 }
 387
 388
 389 DoubleRegister LCodeGen::ToDoubleRegister(int index) const {
 390   return DoubleRegister::FromAllocationIndex(index);
 391 }
 392
 393
 394 Register LCodeGen::ToRegister(LOperand* op) const {
 395   ASSERT(op->IsRegister());
 396   return ToRegister(op->index());
 397 }
 398
 399
 400 Register LCodeGen::EmitLoadRegister(LOperand* op, Register scratch) {
 401   if (op->IsRegister()) {
 402     return ToRegister(op->index());
 403   } else if (op->IsConstantOperand()) {
 404     LConstantOperand* const_op = LConstantOperand::cast(op);
 405     HConstant* constant = chunk_->LookupConstant(const_op);
 406     Handle<Object> literal = constant->handle(isolate());
 407     Representation r = chunk_->LookupLiteralRepresentation(const_op);
 408     if (r.IsInteger32()) {
 409       ASSERT(literal->IsNumber());
 410       __ li(scratch, Operand(static_cast<int32_t>(literal->Number())));
 411     } else if (r.IsSmi()) {
 412       ASSERT(constant->HasSmiValue());
 413       __ li(scratch, Operand(Smi::FromInt(constant->Integer32Value())));
 414     } else if (r.IsDouble()) {
 415       Abort(kEmitLoadRegisterUnsupportedDoubleImmediate);
 416     } else {
 417       ASSERT(r.IsSmiOrTagged());
 418       __ li(scratch, literal);
 419     }
 420     return scratch;
 421   } else if (op->IsStackSlot()) {
 422     __ lw(scratch, ToMemOperand(op));
 423     return scratch;
 424   }
 425   UNREACHABLE();
 426   return scratch;
 427 }
 428
 429
 430 DoubleRegister LCodeGen::ToDoubleRegister(LOperand* op) const {
 431   ASSERT(op->IsDoubleRegister());
 432   return ToDoubleRegister(op->index());
 433 }
 434
 435
 436 DoubleRegister LCodeGen::EmitLoadDoubleRegister(LOperand* op,
 437                                                 FloatRegister flt_scratch,
 438                                                 DoubleRegister dbl_scratch) {
 439   if (op->IsDoubleRegister()) {
 440     return ToDoubleRegister(op->index());
 441   } else if (op->IsConstantOperand()) {
 442     LConstantOperand* const_op = LConstantOperand::cast(op);
 443     HConstant* constant = chunk_->LookupConstant(const_op);
 444     Handle<Object> literal = constant->handle(isolate());
 445     Representation r = chunk_->LookupLiteralRepresentation(const_op);
 446     if (r.IsInteger32()) {
 447       ASSERT(literal->IsNumber());
 448       __ li(at, Operand(static_cast<int32_t>(literal->Number())));
 449       __ mtc1(at, flt_scratch);
 450       __ cvt_d_w(dbl_scratch, flt_scratch);
 451       return dbl_scratch;
 452     } else if (r.IsDouble()) {
 453       Abort(kUnsupportedDoubleImmediate);
 454     } else if (r.IsTagged()) {
 455       Abort(kUnsupportedTaggedImmediate);
 456     }
 457   } else if (op->IsStackSlot()) {
 458     MemOperand mem_op = ToMemOperand(op);
 459     __ ldc1(dbl_scratch, mem_op);
 460     return dbl_scratch;
 461   }
 462   UNREACHABLE();
 463   return dbl_scratch;
 464 }
 465
 466
 467 Handle<Object> LCodeGen::ToHandle(LConstantOperand* op) const {
 468   HConstant* constant = chunk_->LookupConstant(op);
 469   ASSERT(chunk_->LookupLiteralRepresentation(op).IsSmiOrTagged());
 470   return constant->handle(isolate());
 471 }
 472
 473
 474 bool LCodeGen::IsInteger32(LConstantOperand* op) const {
 475   return chunk_->LookupLiteralRepresentation(op).IsSmiOrInteger32();
 476 }
 477
 478
 479 bool LCodeGen::IsSmi(LConstantOperand* op) const {
 480   return chunk_->LookupLiteralRepresentation(op).IsSmi();
 481 }
 482
 483
 484 int32_t LCodeGen::ToInteger32(LConstantOperand* op) const {
 485   return ToRepresentation(op, Representation::Integer32());
 486 }
 487
 488
 489 int32_t LCodeGen::ToRepresentation(LConstantOperand* op,
 490                                    const Representation& r) const {
 491   HConstant* constant = chunk_->LookupConstant(op);
 492   int32_t value = constant->Integer32Value();
 493   if (r.IsInteger32()) return value;
 494   ASSERT(r.IsSmiOrTagged());
 495   return reinterpret_cast<int32_t>(Smi::FromInt(value));
 496 }
 497
 498
 499 Smi* LCodeGen::ToSmi(LConstantOperand* op) const {
 500   HConstant* constant = chunk_->LookupConstant(op);
 501   return Smi::FromInt(constant->Integer32Value());
 502 }
 503
 504
 505 double LCodeGen::ToDouble(LConstantOperand* op) const {
 506   HConstant* constant = chunk_->LookupConstant(op);
 507   ASSERT(constant->HasDoubleValue());
 508   return constant->DoubleValue();
 509 }
 510
 511
 512 Operand LCodeGen::ToOperand(LOperand* op) {
 513   if (op->IsConstantOperand()) {
 514     LConstantOperand* const_op = LConstantOperand::cast(op);
 515     HConstant* constant = chunk()->LookupConstant(const_op);
 516     Representation r = chunk_->LookupLiteralRepresentation(const_op);
 517     if (r.IsSmi()) {
 518       ASSERT(constant->HasSmiValue());
 519       return Operand(Smi::FromInt(constant->Integer32Value()));
 520     } else if (r.IsInteger32()) {
 521       ASSERT(constant->HasInteger32Value());
 522       return Operand(constant->Integer32Value());
 523     } else if (r.IsDouble()) {
 524       Abort(kToOperandUnsupportedDoubleImmediate);
 525     }
 526     ASSERT(r.IsTagged());
 527     return Operand(constant->handle(isolate()));
 528   } else if (op->IsRegister()) {
 529     return Operand(ToRegister(op));
 530   } else if (op->IsDoubleRegister()) {
 531     Abort(kToOperandIsDoubleRegisterUnimplemented);
 532     return Operand(0);
 533   }
 534   // Stack slots not implemented, use ToMemOperand instead.
 535   UNREACHABLE();
 536   return Operand(0);
 537 }
 538
 539
 540 static int ArgumentsOffsetWithoutFrame(int index) {
 541   ASSERT(index < 0);
 542   return -(index + 1) * kPointerSize;
 543 }
 544
 545
 546 MemOperand LCodeGen::ToMemOperand(LOperand* op) const {
 547   ASSERT(!op->IsRegister());
 548   ASSERT(!op->IsDoubleRegister());
 549   ASSERT(op->IsStackSlot() || op->IsDoubleStackSlot());
 550   if (NeedsEagerFrame()) {
 551     return MemOperand(fp, StackSlotOffset(op->index()));
 552   } else {
 553     // Retrieve parameter without eager stack-frame relative to the
 554     // stack-pointer.
 555     return MemOperand(sp, ArgumentsOffsetWithoutFrame(op->index()));
 556   }
 557 }
 558
 559
 560 MemOperand LCodeGen::ToHighMemOperand(LOperand* op) const {
 561   ASSERT(op->IsDoubleStackSlot());
 562   if (NeedsEagerFrame()) {
 563     return MemOperand(fp, StackSlotOffset(op->index()) + kPointerSize);
 564   } else {
 565     // Retrieve parameter without eager stack-frame relative to the
 566     // stack-pointer.
 567     return MemOperand(
 568         sp, ArgumentsOffsetWithoutFrame(op->index()) + kPointerSize);
 569   }
 570 }
 571
 572
 573 void LCodeGen::WriteTranslation(LEnvironment* environment,
 574                                 Translation* translation) {
 575   if (environment == NULL) return;
 576
 577   // The translation includes one command per value in the environment.
 578   int translation_size = environment->translation_size();
 579   // The output frame height does not include the parameters.
 580   int height = translation_size - environment->parameter_count();
 581
 582   WriteTranslation(environment->outer(), translation);
 583   bool has_closure_id = !info()->closure().is_null() &&
 584       !info()->closure().is_identical_to(environment->closure());
 585   int closure_id = has_closure_id
 586       ? DefineDeoptimizationLiteral(environment->closure())
 587       : Translation::kSelfLiteralId;
 588
 589   switch (environment->frame_type()) {
 590     case JS_FUNCTION:
 591       translation->BeginJSFrame(environment->ast_id(), closure_id, height);
 592       break;
 593     case JS_CONSTRUCT:
 594       translation->BeginConstructStubFrame(closure_id, translation_size);
 595       break;
 596     case JS_GETTER:
 597       ASSERT(translation_size == 1);
 598       ASSERT(height == 0);
 599       translation->BeginGetterStubFrame(closure_id);
 600       break;
 601     case JS_SETTER:
 602       ASSERT(translation_size == 2);
 603       ASSERT(height == 0);
 604       translation->BeginSetterStubFrame(closure_id);
 605       break;
 606     case STUB:
 607       translation->BeginCompiledStubFrame();
 608       break;
 609     case ARGUMENTS_ADAPTOR:
 610       translation->BeginArgumentsAdaptorFrame(closure_id, translation_size);
 611       break;
 612   }
 613
 614   int object_index = 0;
 615   int dematerialized_index = 0;
 616   for (int i = 0; i < translation_size; ++i) {
 617     LOperand* value = environment->values()->at(i);
 618     AddToTranslation(environment,
 619                      translation,
 620                      value,
 621                      environment->HasTaggedValueAt(i),
 622                      environment->HasUint32ValueAt(i),
 623                      &object_index,
 624                      &dematerialized_index);
 625   }
 626 }
 627
 628
 629 void LCodeGen::AddToTranslation(LEnvironment* environment,
 630                                 Translation* translation,
 631                                 LOperand* op,
 632                                 bool is_tagged,
 633                                 bool is_uint32,
 634                                 int* object_index_pointer,
 635                                 int* dematerialized_index_pointer) {
 636   if (op == LEnvironment::materialization_marker()) {
 637     int object_index = (*object_index_pointer)++;
 638     if (environment->ObjectIsDuplicateAt(object_index)) {
 639       int dupe_of = environment->ObjectDuplicateOfAt(object_index);
 640       translation->DuplicateObject(dupe_of);
 641       return;
 642     }
 643     int object_length = environment->ObjectLengthAt(object_index);
 644     if (environment->ObjectIsArgumentsAt(object_index)) {
 645       translation->BeginArgumentsObject(object_length);
 646     } else {
 647       translation->BeginCapturedObject(object_length);
 648     }
 649     int dematerialized_index = *dematerialized_index_pointer;
 650     int env_offset = environment->translation_size() + dematerialized_index;
 651     *dematerialized_index_pointer += object_length;
 652     for (int i = 0; i < object_length; ++i) {
 653       LOperand* value = environment->values()->at(env_offset + i);
 654       AddToTranslation(environment,
 655                        translation,
 656                        value,
 657                        environment->HasTaggedValueAt(env_offset + i),
 658                        environment->HasUint32ValueAt(env_offset + i),
 659                        object_index_pointer,
 660                        dematerialized_index_pointer);
 661     }
 662     return;
 663   }
 664
 665   if (op->IsStackSlot()) {
 666     if (is_tagged) {
 667       translation->StoreStackSlot(op->index());
 668     } else if (is_uint32) {
 669       translation->StoreUint32StackSlot(op->index());
 670     } else {
 671       translation->StoreInt32StackSlot(op->index());
 672     }
 673   } else if (op->IsDoubleStackSlot()) {
 674     translation->StoreDoubleStackSlot(op->index());
 675   } else if (op->IsRegister()) {
 676     Register reg = ToRegister(op);
 677     if (is_tagged) {
 678       translation->StoreRegister(reg);
 679     } else if (is_uint32) {
 680       translation->StoreUint32Register(reg);
 681     } else {
 682       translation->StoreInt32Register(reg);
 683     }
 684   } else if (op->IsDoubleRegister()) {
 685     DoubleRegister reg = ToDoubleRegister(op);
 686     translation->StoreDoubleRegister(reg);
 687   } else if (op->IsConstantOperand()) {
 688     HConstant* constant = chunk()->LookupConstant(LConstantOperand::cast(op));
 689     int src_index = DefineDeoptimizationLiteral(constant->handle(isolate()));
 690     translation->StoreLiteral(src_index);
 691   } else {
 692     UNREACHABLE();
 693   }
 694 }
 695
 696
 697 void LCodeGen::CallCode(Handle<Code> code,
 698                         RelocInfo::Mode mode,
 699                         LInstruction* instr) {
 700   CallCodeGeneric(code, mode, instr, RECORD_SIMPLE_SAFEPOINT);
 701 }
 702
 703
 704 void LCodeGen::CallCodeGeneric(Handle<Code> code,
 705                                RelocInfo::Mode mode,
 706                                LInstruction* instr,
 707                                SafepointMode safepoint_mode) {
 708   ASSERT(instr != NULL);
 709   __ Call(code, mode);
 710   RecordSafepointWithLazyDeopt(instr, safepoint_mode);
 711 }
 712
 713
 714 void LCodeGen::CallRuntime(const Runtime::Function* function,
 715                            int num_arguments,
 716                            LInstruction* instr,
 717                            SaveFPRegsMode save_doubles) {
 718   ASSERT(instr != NULL);
 719
 720   __ CallRuntime(function, num_arguments, save_doubles);
 721
 722   RecordSafepointWithLazyDeopt(instr, RECORD_SIMPLE_SAFEPOINT);
 723 }
 724
 725
 726 void LCodeGen::LoadContextFromDeferred(LOperand* context) {
 727   if (context->IsRegister()) {
 728     __ Move(cp, ToRegister(context));
 729   } else if (context->IsStackSlot()) {
 730     __ lw(cp, ToMemOperand(context));
 731   } else if (context->IsConstantOperand()) {
 732     HConstant* constant =
 733         chunk_->LookupConstant(LConstantOperand::cast(context));
 734     __ li(cp, Handle<Object>::cast(constant->handle(isolate())));
 735   } else {
 736     UNREACHABLE();
 737   }
 738 }
 739
 740
 741 void LCodeGen::CallRuntimeFromDeferred(Runtime::FunctionId id,
 742                                        int argc,
 743                                        LInstruction* instr,
 744                                        LOperand* context) {
 745   LoadContextFromDeferred(context);
 746   __ CallRuntimeSaveDoubles(id);
 747   RecordSafepointWithRegisters(
 748       instr->pointer_map(), argc, Safepoint::kNoLazyDeopt);
 749 }
 750
 751
 752 void LCodeGen::RegisterEnvironmentForDeoptimization(LEnvironment* environment,
 753                                                     Safepoint::DeoptMode mode) {
 754   environment->set_has_been_used();
 755   if (!environment->HasBeenRegistered()) {
 756     // Physical stack frame layout:
 757     // -x ............. -4  0 ..................................... y
 758     // [incoming arguments] [spill slots] [pushed outgoing arguments]
 759
 760     // Layout of the environment:
 761     // 0 ..................................................... size-1
 762     // [parameters] [locals] [expression stack including arguments]
 763
 764     // Layout of the translation:
 765     // 0 ........................................................ size - 1 + 4
 766     // [expression stack including arguments] [locals] [4 words] [parameters]
 767     // |>------------  translation_size ------------<|
 768
 769     int frame_count = 0;
 770     int jsframe_count = 0;
 771     for (LEnvironment* e = environment; e != NULL; e = e->outer()) {
 772       ++frame_count;
 773       if (e->frame_type() == JS_FUNCTION) {
 774         ++jsframe_count;
 775       }
 776     }
 777     Translation translation(&translations_, frame_count, jsframe_count, zone());
 778     WriteTranslation(environment, &translation);
 779     int deoptimization_index = deoptimizations_.length();
 780     int pc_offset = masm()->pc_offset();
 781     environment->Register(deoptimization_index,
 782                           translation.index(),
 783                           (mode == Safepoint::kLazyDeopt) ? pc_offset : -1);
 784     deoptimizations_.Add(environment, zone());
 785   }
 786 }
 787
 788
 789 void LCodeGen::DeoptimizeIf(Condition condition,
 790                             LEnvironment* environment,
 791                             Deoptimizer::BailoutType bailout_type,
 792                             Register src1,
 793                             const Operand& src2) {
 794   RegisterEnvironmentForDeoptimization(environment, Safepoint::kNoLazyDeopt);
 795   ASSERT(environment->HasBeenRegistered());
 796   int id = environment->deoptimization_index();
 797   ASSERT(info()->IsOptimizing() || info()->IsStub());
 798   Address entry =
 799       Deoptimizer::GetDeoptimizationEntry(isolate(), id, bailout_type);
 800   if (entry == NULL) {
 801     Abort(kBailoutWasNotPrepared);
 802     return;
 803   }
 804
 805   if (FLAG_deopt_every_n_times != 0 && !info()->IsStub()) {
 806     Register scratch = scratch0();
 807     ExternalReference count = ExternalReference::stress_deopt_count(isolate());
 808     Label no_deopt;
 809     __ Push(a1, scratch);
 810     __ li(scratch, Operand(count));
 811     __ lw(a1, MemOperand(scratch));
 812     __ Subu(a1, a1, Operand(1));
 813     __ Branch(&no_deopt, ne, a1, Operand(zero_reg));
 814     __ li(a1, Operand(FLAG_deopt_every_n_times));
 815     __ sw(a1, MemOperand(scratch));
 816     __ Pop(a1, scratch);
 817
 818     __ Call(entry, RelocInfo::RUNTIME_ENTRY);
 819     __ bind(&no_deopt);
 820     __ sw(a1, MemOperand(scratch));
 821     __ Pop(a1, scratch);
 822   }
 823
 824   if (info()->ShouldTrapOnDeopt()) {
 825     Label skip;
 826     if (condition != al) {
 827       __ Branch(&skip, NegateCondition(condition), src1, src2);
 828     }
 829     __ stop("trap_on_deopt");
 830     __ bind(&skip);
 831   }
 832
 833   ASSERT(info()->IsStub() || frame_is_built_);
 834   // Go through jump table if we need to handle condition, build frame, or
 835   // restore caller doubles.
 836   if (condition == al && frame_is_built_ &&
 837       !info()->saves_caller_doubles()) {
 838     __ Call(entry, RelocInfo::RUNTIME_ENTRY, condition, src1, src2);
 839   } else {
 840     // We often have several deopts to the same entry, reuse the last
 841     // jump entry if this is the case.
 842     if (deopt_jump_table_.is_empty() ||
 843         (deopt_jump_table_.last().address != entry) ||
 844         (deopt_jump_table_.last().bailout_type != bailout_type) ||
 845         (deopt_jump_table_.last().needs_frame != !frame_is_built_)) {
 846       Deoptimizer::JumpTableEntry table_entry(entry,
 847                                               bailout_type,
 848                                               !frame_is_built_);
 849       deopt_jump_table_.Add(table_entry, zone());
 850     }
 851     __ Branch(&deopt_jump_table_.last().label, condition, src1, src2);
 852   }
 853 }
 854
 855
 856 void LCodeGen::DeoptimizeIf(Condition condition,
 857                             LEnvironment* environment,
 858                             Register src1,
 859                             const Operand& src2) {
 860   Deoptimizer::BailoutType bailout_type = info()->IsStub()
 861       ? Deoptimizer::LAZY
 862       : Deoptimizer::EAGER;
 863   DeoptimizeIf(condition, environment, bailout_type, src1, src2);
 864 }
 865
 866
 867 void LCodeGen::PopulateDeoptimizationData(Handle<Code> code) {
 868   int length = deoptimizations_.length();
 869   if (length == 0) return;
 870   Handle<DeoptimizationInputData> data =
 871       DeoptimizationInputData::New(isolate(), length, TENURED);
 872
 873   Handle<ByteArray> translations =
 874       translations_.CreateByteArray(isolate()->factory());
 875   data->SetTranslationByteArray(*translations);
 876   data->SetInlinedFunctionCount(Smi::FromInt(inlined_function_count_));
 877   data->SetOptimizationId(Smi::FromInt(info_->optimization_id()));
 878   if (info_->IsOptimizing()) {
 879     // Reference to shared function info does not change between phases.
 880     AllowDeferredHandleDereference allow_handle_dereference;
 881     data->SetSharedFunctionInfo(*info_->shared_info());
 882   } else {
 883     data->SetSharedFunctionInfo(Smi::FromInt(0));
 884   }
 885
 886   Handle<FixedArray> literals =
 887       factory()->NewFixedArray(deoptimization_literals_.length(), TENURED);
 888   { AllowDeferredHandleDereference copy_handles;
 889     for (int i = 0; i < deoptimization_literals_.length(); i++) {
 890       literals->set(i, *deoptimization_literals_[i]);
 891     }
 892     data->SetLiteralArray(*literals);
 893   }
 894
 895   data->SetOsrAstId(Smi::FromInt(info_->osr_ast_id().ToInt()));
 896   data->SetOsrPcOffset(Smi::FromInt(osr_pc_offset_));
 897
 898   // Populate the deoptimization entries.
 899   for (int i = 0; i < length; i++) {
 900     LEnvironment* env = deoptimizations_[i];
 901     data->SetAstId(i, env->ast_id());
 902     data->SetTranslationIndex(i, Smi::FromInt(env->translation_index()));
 903     data->SetArgumentsStackHeight(i,
 904                                   Smi::FromInt(env->arguments_stack_height()));
 905     data->SetPc(i, Smi::FromInt(env->pc_offset()));
 906   }
 907   code->set_deoptimization_data(*data);
 908 }
 909
 910
 911 int LCodeGen::DefineDeoptimizationLiteral(Handle<Object> literal) {
 912   int result = deoptimization_literals_.length();
 913   for (int i = 0; i < deoptimization_literals_.length(); ++i) {
 914     if (deoptimization_literals_[i].is_identical_to(literal)) return i;
 915   }
 916   deoptimization_literals_.Add(literal, zone());
 917   return result;
 918 }
 919
 920
 921 void LCodeGen::PopulateDeoptimizationLiteralsWithInlinedFunctions() {
 922   ASSERT(deoptimization_literals_.length() == 0);
 923
 924   const ZoneList<Handle<JSFunction> >* inlined_closures =
 925       chunk()->inlined_closures();
 926
 927   for (int i = 0, length = inlined_closures->length();
 928        i < length;
 929        i++) {
 930     DefineDeoptimizationLiteral(inlined_closures->at(i));
 931   }
 932
 933   inlined_function_count_ = deoptimization_literals_.length();
 934 }
 935
 936
 937 void LCodeGen::RecordSafepointWithLazyDeopt(
 938     LInstruction* instr, SafepointMode safepoint_mode) {
 939   if (safepoint_mode == RECORD_SIMPLE_SAFEPOINT) {
 940     RecordSafepoint(instr->pointer_map(), Safepoint::kLazyDeopt);
 941   } else {
 942     ASSERT(safepoint_mode == RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS);
 943     RecordSafepointWithRegisters(
 944         instr->pointer_map(), 0, Safepoint::kLazyDeopt);
 945   }
 946 }
 947
 948
 949 void LCodeGen::RecordSafepoint(
 950     LPointerMap* pointers,
 951     Safepoint::Kind kind,
 952     int arguments,
 953     Safepoint::DeoptMode deopt_mode) {
 954   ASSERT(expected_safepoint_kind_ == kind);
 955
 956   const ZoneList<LOperand*>* operands = pointers->GetNormalizedOperands();
 957   Safepoint safepoint = safepoints_.DefineSafepoint(masm(),
 958       kind, arguments, deopt_mode);
 959   for (int i = 0; i < operands->length(); i++) {
 960     LOperand* pointer = operands->at(i);
 961     if (pointer->IsStackSlot()) {
 962       safepoint.DefinePointerSlot(pointer->index(), zone());
 963     } else if (pointer->IsRegister() && (kind & Safepoint::kWithRegisters)) {
 964       safepoint.DefinePointerRegister(ToRegister(pointer), zone());
 965     }
 966   }
 967 }
 968
 969
 970 void LCodeGen::RecordSafepoint(LPointerMap* pointers,
 971                                Safepoint::DeoptMode deopt_mode) {
 972   RecordSafepoint(pointers, Safepoint::kSimple, 0, deopt_mode);
 973 }
 974
 975
 976 void LCodeGen::RecordSafepoint(Safepoint::DeoptMode deopt_mode) {
 977   LPointerMap empty_pointers(zone());
 978   RecordSafepoint(&empty_pointers, deopt_mode);
 979 }
 980
 981
 982 void LCodeGen::RecordSafepointWithRegisters(LPointerMap* pointers,
 983                                             int arguments,
 984                                             Safepoint::DeoptMode deopt_mode) {
 985   RecordSafepoint(
 986       pointers, Safepoint::kWithRegisters, arguments, deopt_mode);
 987 }
 988
 989
 990 void LCodeGen::RecordSafepointWithRegistersAndDoubles(
 991     LPointerMap* pointers,
 992     int arguments,
 993     Safepoint::DeoptMode deopt_mode) {
 994   RecordSafepoint(
 995       pointers, Safepoint::kWithRegistersAndDoubles, arguments, deopt_mode);
 996 }
 997
 998
 999 void LCodeGen::RecordAndWritePosition(int position) {
1000   if (position == RelocInfo::kNoPosition) return;
1001   masm()->positions_recorder()->RecordPosition(position);
1002   masm()->positions_recorder()->WriteRecordedPositions();
1003 }
1004
1005
1006 static const char* LabelType(LLabel* label) {
1007   if (label->is_loop_header()) return " (loop header)";
1008   if (label->is_osr_entry()) return " (OSR entry)";
1009   return "";
1010 }
1011
1012
1013 void LCodeGen::DoLabel(LLabel* label) {
1014   Comment(";;; <@%d,#%d> -------------------- B%d%s --------------------",
1015           current_instruction_,
1016           label->hydrogen_value()->id(),
1017           label->block_id(),
1018           LabelType(label));
1019   __ bind(label->label());
1020   current_block_ = label->block_id();
1021   DoGap(label);
1022 }
1023
1024
1025 void LCodeGen::DoParallelMove(LParallelMove* move) {
1026   resolver_.Resolve(move);
1027 }
1028
1029
1030 void LCodeGen::DoGap(LGap* gap) {
1031   for (int i = LGap::FIRST_INNER_POSITION;
1032        i <= LGap::LAST_INNER_POSITION;
1033        i++) {
1034     LGap::InnerPosition inner_pos = static_cast<LGap::InnerPosition>(i);
1035     LParallelMove* move = gap->GetParallelMove(inner_pos);
1036     if (move != NULL) DoParallelMove(move);
1037   }
1038 }
1039
1040
1041 void LCodeGen::DoInstructionGap(LInstructionGap* instr) {
1042   DoGap(instr);
1043 }
1044
1045
1046 void LCodeGen::DoParameter(LParameter* instr) {
1047   // Nothing to do.
1048 }
1049
1050
1051 void LCodeGen::DoCallStub(LCallStub* instr) {
1052   ASSERT(ToRegister(instr->context()).is(cp));
1053   ASSERT(ToRegister(instr->result()).is(v0));
1054   switch (instr->hydrogen()->major_key()) {
1055     case CodeStub::RegExpExec: {
1056       RegExpExecStub stub(isolate());
1057       CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr);
1058       break;
1059     }
1060     case CodeStub::SubString: {
1061       SubStringStub stub(isolate());
1062       CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr);
1063       break;
1064     }
1065     case CodeStub::StringCompare: {
1066       StringCompareStub stub(isolate());
1067       CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr);
1068       break;
1069     }
1070     default:
1071       UNREACHABLE();
1072   }
1073 }
1074
1075
1076 void LCodeGen::DoUnknownOSRValue(LUnknownOSRValue* instr) {
1077   GenerateOsrPrologue();
1078 }
1079
1080
1081 void LCodeGen::DoModByPowerOf2I(LModByPowerOf2I* instr) {
1082   Register dividend = ToRegister(instr->dividend());
1083   int32_t divisor = instr->divisor();
1084   ASSERT(dividend.is(ToRegister(instr->result())));
1085
1086   // Theoretically, a variation of the branch-free code for integer division by
1087   // a power of 2 (calculating the remainder via an additional multiplication
1088   // (which gets simplified to an 'and') and subtraction) should be faster, and
1089   // this is exactly what GCC and clang emit. Nevertheless, benchmarks seem to
1090   // indicate that positive dividends are heavily favored, so the branching
1091   // version performs better.
1092   HMod* hmod = instr->hydrogen();
1093   int32_t mask = divisor < 0 ? -(divisor + 1) : (divisor - 1);
1094   Label dividend_is_not_negative, done;
1095
1096   if (hmod->CheckFlag(HValue::kLeftCanBeNegative)) {
1097     __ Branch(&dividend_is_not_negative, ge, dividend, Operand(zero_reg));
1098     // Note: The code below even works when right contains kMinInt.
1099     __ subu(dividend, zero_reg, dividend);
1100     __ And(dividend, dividend, Operand(mask));
1101     if (hmod->CheckFlag(HValue::kBailoutOnMinusZero)) {
1102       DeoptimizeIf(eq, instr->environment(), dividend, Operand(zero_reg));
1103     }
1104     __ Branch(USE_DELAY_SLOT, &done);
1105     __ subu(dividend, zero_reg, dividend);
1106   }
1107
1108   __ bind(&dividend_is_not_negative);
1109   __ And(dividend, dividend, Operand(mask));
1110   __ bind(&done);
1111 }
1112
1113
1114 void LCodeGen::DoModByConstI(LModByConstI* instr) {
1115   Register dividend = ToRegister(instr->dividend());
1116   int32_t divisor = instr->divisor();
1117   Register result = ToRegister(instr->result());
1118   ASSERT(!dividend.is(result));
1119
1120   if (divisor == 0) {
1121     DeoptimizeIf(al, instr->environment());
1122     return;
1123   }
1124
1125   __ TruncatingDiv(result, dividend, Abs(divisor));
1126   __ Mul(result, result, Operand(Abs(divisor)));
1127   __ Subu(result, dividend, Operand(result));
1128
1129   // Check for negative zero.
1130   HMod* hmod = instr->hydrogen();
1131   if (hmod->CheckFlag(HValue::kBailoutOnMinusZero)) {
1132     Label remainder_not_zero;
1133     __ Branch(&remainder_not_zero, ne, result, Operand(zero_reg));
1134     DeoptimizeIf(lt, instr->environment(), dividend, Operand(zero_reg));
1135     __ bind(&remainder_not_zero);
1136   }
1137 }
1138
1139
1140 void LCodeGen::DoModI(LModI* instr) {
1141   HMod* hmod = instr->hydrogen();
1142   const Register left_reg = ToRegister(instr->left());
1143   const Register right_reg = ToRegister(instr->right());
1144   const Register result_reg = ToRegister(instr->result());
1145
1146   // div runs in the background while we check for special cases.
1147   __ div(left_reg, right_reg);
1148
1149   Label done;
1150   // Check for x % 0, we have to deopt in this case because we can't return a
1151   // NaN.
1152   if (hmod->CheckFlag(HValue::kCanBeDivByZero)) {
1153     DeoptimizeIf(eq, instr->environment(), right_reg, Operand(zero_reg));
1154   }
1155
1156   // Check for kMinInt % -1, div will return kMinInt, which is not what we
1157   // want. We have to deopt if we care about -0, because we can't return that.
1158   if (hmod->CheckFlag(HValue::kCanOverflow)) {
1159     Label no_overflow_possible;
1160     __ Branch(&no_overflow_possible, ne, left_reg, Operand(kMinInt));
1161     if (hmod->CheckFlag(HValue::kBailoutOnMinusZero)) {
1162       DeoptimizeIf(eq, instr->environment(), right_reg, Operand(-1));
1163     } else {
1164       __ Branch(&no_overflow_possible, ne, right_reg, Operand(-1));
1165       __ Branch(USE_DELAY_SLOT, &done);
1166       __ mov(result_reg, zero_reg);
1167     }
1168     __ bind(&no_overflow_possible);
1169   }
1170
1171   // If we care about -0, test if the dividend is <0 and the result is 0.
1172   __ Branch(USE_DELAY_SLOT, &done, ge, left_reg, Operand(zero_reg));
1173   __ mfhi(result_reg);
1174   if (hmod->CheckFlag(HValue::kBailoutOnMinusZero)) {
1175     DeoptimizeIf(eq, instr->environment(), result_reg, Operand(zero_reg));
1176   }
1177   __ bind(&done);
1178 }
1179
1180
1181 void LCodeGen::DoDivByPowerOf2I(LDivByPowerOf2I* instr) {
1182   Register dividend = ToRegister(instr->dividend());
1183   int32_t divisor = instr->divisor();
1184   Register result = ToRegister(instr->result());
1185   ASSERT(divisor == kMinInt || IsPowerOf2(Abs(divisor)));
1186   ASSERT(!result.is(dividend));
1187
1188   // Check for (0 / -x) that will produce negative zero.
1189   HDiv* hdiv = instr->hydrogen();
1190   if (hdiv->CheckFlag(HValue::kBailoutOnMinusZero) && divisor < 0) {
1191     DeoptimizeIf(eq, instr->environment(), dividend, Operand(zero_reg));
1192   }
1193   // Check for (kMinInt / -1).
1194   if (hdiv->CheckFlag(HValue::kCanOverflow) && divisor == -1) {
1195     DeoptimizeIf(eq, instr->environment(), dividend, Operand(kMinInt));
1196   }
1197   // Deoptimize if remainder will not be 0.
1198   if (!hdiv->CheckFlag(HInstruction::kAllUsesTruncatingToInt32) &&
1199       divisor != 1 && divisor != -1) {
1200     int32_t mask = divisor < 0 ? -(divisor + 1) : (divisor - 1);
1201     __ And(at, dividend, Operand(mask));
1202     DeoptimizeIf(ne, instr->environment(), at, Operand(zero_reg));
1203   }
1204
1205   if (divisor == -1) {  // Nice shortcut, not needed for correctness.
1206     __ Subu(result, zero_reg, dividend);
1207     return;
1208   }
1209   uint16_t shift = WhichPowerOf2Abs(divisor);
1210   if (shift == 0) {
1211     __ Move(result, dividend);
1212   } else if (shift == 1) {
1213     __ srl(result, dividend, 31);
1214     __ Addu(result, dividend, Operand(result));
1215   } else {
1216     __ sra(result, dividend, 31);
1217     __ srl(result, result, 32 - shift);
1218     __ Addu(result, dividend, Operand(result));
1219   }
1220   if (shift > 0) __ sra(result, result, shift);
1221   if (divisor < 0) __ Subu(result, zero_reg, result);
1222 }
1223
1224
1225 void LCodeGen::DoDivByConstI(LDivByConstI* instr) {
1226   Register dividend = ToRegister(instr->dividend());
1227   int32_t divisor = instr->divisor();
1228   Register result = ToRegister(instr->result());
1229   ASSERT(!dividend.is(result));
1230
1231   if (divisor == 0) {
1232     DeoptimizeIf(al, instr->environment());
1233     return;
1234   }
1235
1236   // Check for (0 / -x) that will produce negative zero.
1237   HDiv* hdiv = instr->hydrogen();
1238   if (hdiv->CheckFlag(HValue::kBailoutOnMinusZero) && divisor < 0) {
1239     DeoptimizeIf(eq, instr->environment(), dividend, Operand(zero_reg));
1240   }
1241
1242   __ TruncatingDiv(result, dividend, Abs(divisor));
1243   if (divisor < 0) __ Subu(result, zero_reg, result);
1244
1245   if (!hdiv->CheckFlag(HInstruction::kAllUsesTruncatingToInt32)) {
1246     __ Mul(scratch0(), result, Operand(divisor));
1247     __ Subu(scratch0(), scratch0(), dividend);
1248     DeoptimizeIf(ne, instr->environment(), scratch0(), Operand(zero_reg));
1249   }
1250 }
1251
1252
1253 // TODO(svenpanne) Refactor this to avoid code duplication with DoFlooringDivI.
1254 void LCodeGen::DoDivI(LDivI* instr) {
1255   HBinaryOperation* hdiv = instr->hydrogen();
1256   Register dividend = ToRegister(instr->dividend());
1257   Register divisor = ToRegister(instr->divisor());
1258   const Register result = ToRegister(instr->result());
1259
1260   // On MIPS div is asynchronous - it will run in the background while we
1261   // check for special cases.
1262   __ div(dividend, divisor);
1263
1264   // Check for x / 0.
1265   if (hdiv->CheckFlag(HValue::kCanBeDivByZero)) {
1266     DeoptimizeIf(eq, instr->environment(), divisor, Operand(zero_reg));
1267   }
1268
1269   // Check for (0 / -x) that will produce negative zero.
1270   if (hdiv->CheckFlag(HValue::kBailoutOnMinusZero)) {
1271     Label left_not_zero;
1272     __ Branch(&left_not_zero, ne, dividend, Operand(zero_reg));
1273     DeoptimizeIf(lt, instr->environment(), divisor, Operand(zero_reg));
1274     __ bind(&left_not_zero);
1275   }
1276
1277   // Check for (kMinInt / -1).
1278   if (hdiv->CheckFlag(HValue::kCanOverflow) &&
1279       !hdiv->CheckFlag(HValue::kAllUsesTruncatingToInt32)) {
1280     Label left_not_min_int;
1281     __ Branch(&left_not_min_int, ne, dividend, Operand(kMinInt));
1282     DeoptimizeIf(eq, instr->environment(), divisor, Operand(-1));
1283     __ bind(&left_not_min_int);
1284   }
1285
1286   if (!hdiv->CheckFlag(HValue::kAllUsesTruncatingToInt32)) {
1287     __ mfhi(result);
1288     DeoptimizeIf(ne, instr->environment(), result, Operand(zero_reg));
1289     __ mflo(result);
1290   } else {
1291     __ mflo(result);
1292   }
1293 }
1294
1295
1296 void LCodeGen::DoMultiplyAddD(LMultiplyAddD* instr) {
1297   DoubleRegister addend = ToDoubleRegister(instr->addend());
1298   DoubleRegister multiplier = ToDoubleRegister(instr->multiplier());
1299   DoubleRegister multiplicand = ToDoubleRegister(instr->multiplicand());
1300
1301   // This is computed in-place.
1302   ASSERT(addend.is(ToDoubleRegister(instr->result())));
1303
1304   __ madd_d(addend, addend, multiplier, multiplicand);
1305 }
1306
1307
1308 void LCodeGen::DoFlooringDivByPowerOf2I(LFlooringDivByPowerOf2I* instr) {
1309   Register dividend = ToRegister(instr->dividend());
1310   Register result = ToRegister(instr->result());
1311   int32_t divisor = instr->divisor();
1312   Register scratch = result.is(dividend) ? scratch0() : dividend;
1313   ASSERT(!result.is(dividend) || !scratch.is(dividend));
1314
1315   // If the divisor is 1, return the dividend.
1316   if (divisor == 1) {
1317     __ Move(result, dividend);
1318     return;
1319   }
1320
1321   // If the divisor is positive, things are easy: There can be no deopts and we
1322   // can simply do an arithmetic right shift.
1323   uint16_t shift = WhichPowerOf2Abs(divisor);
1324   if (divisor > 1) {
1325     __ sra(result, dividend, shift);
1326     return;
1327   }
1328
1329   // If the divisor is negative, we have to negate and handle edge cases.
1330
1331   // dividend can be the same register as result so save the value of it
1332   // for checking overflow.
1333   __ Move(scratch, dividend);
1334
1335   __ Subu(result, zero_reg, dividend);
1336   if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
1337     DeoptimizeIf(eq, instr->environment(), result, Operand(zero_reg));
1338   }
1339
1340   // Dividing by -1 is basically negation, unless we overflow.
1341   __ Xor(scratch, scratch, result);
1342   if (divisor == -1) {
1343     if (instr->hydrogen()->CheckFlag(HValue::kLeftCanBeMinInt)) {
1344       DeoptimizeIf(ge, instr->environment(), scratch, Operand(zero_reg));
1345     }
1346     return;
1347   }
1348
1349   // If the negation could not overflow, simply shifting is OK.
1350   if (!instr->hydrogen()->CheckFlag(HValue::kLeftCanBeMinInt)) {
1351     __ sra(result, result, shift);
1352     return;
1353   }
1354
1355   Label no_overflow, done;
1356   __ Branch(&no_overflow, lt, scratch, Operand(zero_reg));
1357   __ li(result, Operand(kMinInt / divisor));
1358   __ Branch(&done);
1359   __ bind(&no_overflow);
1360   __ sra(result, result, shift);
1361   __ bind(&done);
1362 }
1363
1364
1365 void LCodeGen::DoFlooringDivByConstI(LFlooringDivByConstI* instr) {
1366   Register dividend = ToRegister(instr->dividend());
1367   int32_t divisor = instr->divisor();
1368   Register result = ToRegister(instr->result());
1369   ASSERT(!dividend.is(result));
1370
1371   if (divisor == 0) {
1372     DeoptimizeIf(al, instr->environment());
1373     return;
1374   }
1375
1376   // Check for (0 / -x) that will produce negative zero.
1377   HMathFloorOfDiv* hdiv = instr->hydrogen();
1378   if (hdiv->CheckFlag(HValue::kBailoutOnMinusZero) && divisor < 0) {
1379     DeoptimizeIf(eq, instr->environment(), dividend, Operand(zero_reg));
1380   }
1381
1382   // Easy case: We need no dynamic check for the dividend and the flooring
1383   // division is the same as the truncating division.
1384   if ((divisor > 0 && !hdiv->CheckFlag(HValue::kLeftCanBeNegative)) ||
1385       (divisor < 0 && !hdiv->CheckFlag(HValue::kLeftCanBePositive))) {
1386     __ TruncatingDiv(result, dividend, Abs(divisor));
1387     if (divisor < 0) __ Subu(result, zero_reg, result);
1388     return;
1389   }
1390
1391   // In the general case we may need to adjust before and after the truncating
1392   // division to get a flooring division.
1393   Register temp = ToRegister(instr->temp());
1394   ASSERT(!temp.is(dividend) && !temp.is(result));
1395   Label needs_adjustment, done;
1396   __ Branch(&needs_adjustment, divisor > 0 ? lt : gt,
1397             dividend, Operand(zero_reg));
1398   __ TruncatingDiv(result, dividend, Abs(divisor));
1399   if (divisor < 0) __ Subu(result, zero_reg, result);
1400   __ jmp(&done);
1401   __ bind(&needs_adjustment);
1402   __ Addu(temp, dividend, Operand(divisor > 0 ? 1 : -1));
1403   __ TruncatingDiv(result, temp, Abs(divisor));
1404   if (divisor < 0) __ Subu(result, zero_reg, result);
1405   __ Subu(result, result, Operand(1));
1406   __ bind(&done);
1407 }
1408
1409
1410 // TODO(svenpanne) Refactor this to avoid code duplication with DoDivI.
1411 void LCodeGen::DoFlooringDivI(LFlooringDivI* instr) {
1412   HBinaryOperation* hdiv = instr->hydrogen();
1413   Register dividend = ToRegister(instr->dividend());
1414   Register divisor = ToRegister(instr->divisor());
1415   const Register result = ToRegister(instr->result());
1416
1417   // On MIPS div is asynchronous - it will run in the background while we
1418   // check for special cases.
1419   __ div(dividend, divisor);
1420
1421   // Check for x / 0.
1422   if (hdiv->CheckFlag(HValue::kCanBeDivByZero)) {
1423     DeoptimizeIf(eq, instr->environment(), divisor, Operand(zero_reg));
1424   }
1425
1426   // Check for (0 / -x) that will produce negative zero.
1427   if (hdiv->CheckFlag(HValue::kBailoutOnMinusZero)) {
1428     Label left_not_zero;
1429     __ Branch(&left_not_zero, ne, dividend, Operand(zero_reg));
1430     DeoptimizeIf(lt, instr->environment(), divisor, Operand(zero_reg));
1431     __ bind(&left_not_zero);
1432   }
1433
1434   // Check for (kMinInt / -1).
1435   if (hdiv->CheckFlag(HValue::kCanOverflow) &&
1436       !hdiv->CheckFlag(HValue::kAllUsesTruncatingToInt32)) {
1437     Label left_not_min_int;
1438     __ Branch(&left_not_min_int, ne, dividend, Operand(kMinInt));
1439     DeoptimizeIf(eq, instr->environment(), divisor, Operand(-1));
1440     __ bind(&left_not_min_int);
1441   }
1442
1443   // We performed a truncating division. Correct the result if necessary.
1444   Label done;
1445   Register remainder = scratch0();
1446   __ mfhi(remainder);
1447   __ mflo(result);
1448   __ Branch(&done, eq, remainder, Operand(zero_reg), USE_DELAY_SLOT);
1449   __ Xor(remainder, remainder, Operand(divisor));
1450   __ Branch(&done, ge, remainder, Operand(zero_reg));
1451   __ Subu(result, result, Operand(1));
1452   __ bind(&done);
1453 }
1454
1455
1456 void LCodeGen::DoMulI(LMulI* instr) {
1457   Register scratch = scratch0();
1458   Register result = ToRegister(instr->result());
1459   // Note that result may alias left.
1460   Register left = ToRegister(instr->left());
1461   LOperand* right_op = instr->right();
1462
1463   bool bailout_on_minus_zero =
1464     instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero);
1465   bool overflow = instr->hydrogen()->CheckFlag(HValue::kCanOverflow);
1466
1467   if (right_op->IsConstantOperand()) {
1468     int32_t constant = ToInteger32(LConstantOperand::cast(right_op));
1469
1470     if (bailout_on_minus_zero && (constant < 0)) {
1471       // The case of a null constant will be handled separately.
1472       // If constant is negative and left is null, the result should be -0.
1473       DeoptimizeIf(eq, instr->environment(), left, Operand(zero_reg));
1474     }
1475
1476     switch (constant) {
1477       case -1:
1478         if (overflow) {
1479           __ SubuAndCheckForOverflow(result, zero_reg, left, scratch);
1480           DeoptimizeIf(lt, instr->environment(), scratch, Operand(zero_reg));
1481         } else {
1482           __ Subu(result, zero_reg, left);
1483         }
1484         break;
1485       case 0:
1486         if (bailout_on_minus_zero) {
1487           // If left is strictly negative and the constant is null, the
1488           // result is -0. Deoptimize if required, otherwise return 0.
1489           DeoptimizeIf(lt, instr->environment(), left, Operand(zero_reg));
1490         }
1491         __ mov(result, zero_reg);
1492         break;
1493       case 1:
1494         // Nothing to do.
1495         __ Move(result, left);
1496         break;
1497       default:
1498         // Multiplying by powers of two and powers of two plus or minus
1499         // one can be done faster with shifted operands.
1500         // For other constants we emit standard code.
1501         int32_t mask = constant >> 31;
1502         uint32_t constant_abs = (constant + mask) ^ mask;
1503
1504         if (IsPowerOf2(constant_abs)) {
1505           int32_t shift = WhichPowerOf2(constant_abs);
1506           __ sll(result, left, shift);
1507           // Correct the sign of the result if the constant is negative.
1508           if (constant < 0)  __ Subu(result, zero_reg, result);
1509         } else if (IsPowerOf2(constant_abs - 1)) {
1510           int32_t shift = WhichPowerOf2(constant_abs - 1);
1511           __ sll(scratch, left, shift);
1512           __ Addu(result, scratch, left);
1513           // Correct the sign of the result if the constant is negative.
1514           if (constant < 0)  __ Subu(result, zero_reg, result);
1515         } else if (IsPowerOf2(constant_abs + 1)) {
1516           int32_t shift = WhichPowerOf2(constant_abs + 1);
1517           __ sll(scratch, left, shift);
1518           __ Subu(result, scratch, left);
1519           // Correct the sign of the result if the constant is negative.
1520           if (constant < 0)  __ Subu(result, zero_reg, result);
1521         } else {
1522           // Generate standard code.
1523           __ li(at, constant);
1524           __ Mul(result, left, at);
1525         }
1526     }
1527
1528   } else {
1529     ASSERT(right_op->IsRegister());
1530     Register right = ToRegister(right_op);
1531
1532     if (overflow) {
1533       // hi:lo = left * right.
1534       if (instr->hydrogen()->representation().IsSmi()) {
1535         __ SmiUntag(result, left);
1536         __ mult(result, right);
1537         __ mfhi(scratch);
1538         __ mflo(result);
1539       } else {
1540         __ mult(left, right);
1541         __ mfhi(scratch);
1542         __ mflo(result);
1543       }
1544       __ sra(at, result, 31);
1545       DeoptimizeIf(ne, instr->environment(), scratch, Operand(at));
1546     } else {
1547       if (instr->hydrogen()->representation().IsSmi()) {
1548         __ SmiUntag(result, left);
1549         __ Mul(result, result, right);
1550       } else {
1551         __ Mul(result, left, right);
1552       }
1553     }
1554
1555     if (bailout_on_minus_zero) {
1556       Label done;
1557       __ Xor(at, left, right);
1558       __ Branch(&done, ge, at, Operand(zero_reg));
1559       // Bail out if the result is minus zero.
1560       DeoptimizeIf(eq,
1561                    instr->environment(),
1562                    result,
1563                    Operand(zero_reg));
1564       __ bind(&done);
1565     }
1566   }
1567 }
1568
1569
1570 void LCodeGen::DoBitI(LBitI* instr) {
1571   LOperand* left_op = instr->left();
1572   LOperand* right_op = instr->right();
1573   ASSERT(left_op->IsRegister());
1574   Register left = ToRegister(left_op);
1575   Register result = ToRegister(instr->result());
1576   Operand right(no_reg);
1577
1578   if (right_op->IsStackSlot()) {
1579     right = Operand(EmitLoadRegister(right_op, at));
1580   } else {
1581     ASSERT(right_op->IsRegister() || right_op->IsConstantOperand());
1582     right = ToOperand(right_op);
1583   }
1584
1585   switch (instr->op()) {
1586     case Token::BIT_AND:
1587       __ And(result, left, right);
1588       break;
1589     case Token::BIT_OR:
1590       __ Or(result, left, right);
1591       break;
1592     case Token::BIT_XOR:
1593       if (right_op->IsConstantOperand() && right.immediate() == int32_t(~0)) {
1594         __ Nor(result, zero_reg, left);
1595       } else {
1596         __ Xor(result, left, right);
1597       }
1598       break;
1599     default:
1600       UNREACHABLE();
1601       break;
1602   }
1603 }
1604
1605
1606 void LCodeGen::DoShiftI(LShiftI* instr) {
1607   // Both 'left' and 'right' are "used at start" (see LCodeGen::DoShift), so
1608   // result may alias either of them.
1609   LOperand* right_op = instr->right();
1610   Register left = ToRegister(instr->left());
1611   Register result = ToRegister(instr->result());
1612   Register scratch = scratch0();
1613
1614   if (right_op->IsRegister()) {
1615     // No need to mask the right operand on MIPS, it is built into the variable
1616     // shift instructions.
1617     switch (instr->op()) {
1618       case Token::ROR:
1619         __ Ror(result, left, Operand(ToRegister(right_op)));
1620         break;
1621       case Token::SAR:
1622         __ srav(result, left, ToRegister(right_op));
1623         break;
1624       case Token::SHR:
1625         __ srlv(result, left, ToRegister(right_op));
1626         if (instr->can_deopt()) {
1627           DeoptimizeIf(lt, instr->environment(), result, Operand(zero_reg));
1628         }
1629         break;
1630       case Token::SHL:
1631         __ sllv(result, left, ToRegister(right_op));
1632         break;
1633       default:
1634         UNREACHABLE();
1635         break;
1636     }
1637   } else {
1638     // Mask the right_op operand.
1639     int value = ToInteger32(LConstantOperand::cast(right_op));
1640     uint8_t shift_count = static_cast<uint8_t>(value & 0x1F);
1641     switch (instr->op()) {
1642       case Token::ROR:
1643         if (shift_count != 0) {
1644           __ Ror(result, left, Operand(shift_count));
1645         } else {
1646           __ Move(result, left);
1647         }
1648         break;
1649       case Token::SAR:
1650         if (shift_count != 0) {
1651           __ sra(result, left, shift_count);
1652         } else {
1653           __ Move(result, left);
1654         }
1655         break;
1656       case Token::SHR:
1657         if (shift_count != 0) {
1658           __ srl(result, left, shift_count);
1659         } else {
1660           if (instr->can_deopt()) {
1661             __ And(at, left, Operand(0x80000000));
1662             DeoptimizeIf(ne, instr->environment(), at, Operand(zero_reg));
1663           }
1664           __ Move(result, left);
1665         }
1666         break;
1667       case Token::SHL:
1668         if (shift_count != 0) {
1669           if (instr->hydrogen_value()->representation().IsSmi() &&
1670               instr->can_deopt()) {
1671             if (shift_count != 1) {
1672               __ sll(result, left, shift_count - 1);
1673               __ SmiTagCheckOverflow(result, result, scratch);
1674             } else {
1675               __ SmiTagCheckOverflow(result, left, scratch);
1676             }
1677             DeoptimizeIf(lt, instr->environment(), scratch, Operand(zero_reg));
1678           } else {
1679             __ sll(result, left, shift_count);
1680           }
1681         } else {
1682           __ Move(result, left);
1683         }
1684         break;
1685       default:
1686         UNREACHABLE();
1687         break;
1688     }
1689   }
1690 }
1691
1692
1693 void LCodeGen::DoSubI(LSubI* instr) {
1694   LOperand* left = instr->left();
1695   LOperand* right = instr->right();
1696   LOperand* result = instr->result();
1697   bool can_overflow = instr->hydrogen()->CheckFlag(HValue::kCanOverflow);
1698
1699   if (!can_overflow) {
1700     if (right->IsStackSlot()) {
1701       Register right_reg = EmitLoadRegister(right, at);
1702       __ Subu(ToRegister(result), ToRegister(left), Operand(right_reg));
1703     } else {
1704       ASSERT(right->IsRegister() || right->IsConstantOperand());
1705       __ Subu(ToRegister(result), ToRegister(left), ToOperand(right));
1706     }
1707   } else {  // can_overflow.
1708     Register overflow = scratch0();
1709     Register scratch = scratch1();
1710     if (right->IsStackSlot() || right->IsConstantOperand()) {
1711       Register right_reg = EmitLoadRegister(right, scratch);
1712       __ SubuAndCheckForOverflow(ToRegister(result),
1713                                  ToRegister(left),
1714                                  right_reg,
1715                                  overflow);  // Reg at also used as scratch.
1716     } else {
1717       ASSERT(right->IsRegister());
1718       // Due to overflow check macros not supporting constant operands,
1719       // handling the IsConstantOperand case was moved to prev if clause.
1720       __ SubuAndCheckForOverflow(ToRegister(result),
1721                                  ToRegister(left),
1722                                  ToRegister(right),
1723                                  overflow);  // Reg at also used as scratch.
1724     }
1725     DeoptimizeIf(lt, instr->environment(), overflow, Operand(zero_reg));
1726   }
1727 }
1728
1729
1730 void LCodeGen::DoConstantI(LConstantI* instr) {
1731   __ li(ToRegister(instr->result()), Operand(instr->value()));
1732 }
1733
1734
1735 void LCodeGen::DoConstantS(LConstantS* instr) {
1736   __ li(ToRegister(instr->result()), Operand(instr->value()));
1737 }
1738
1739
1740 void LCodeGen::DoConstantD(LConstantD* instr) {
1741   ASSERT(instr->result()->IsDoubleRegister());
1742   DoubleRegister result = ToDoubleRegister(instr->result());
1743   double v = instr->value();
1744   __ Move(result, v);
1745 }
1746
1747
1748 void LCodeGen::DoConstantE(LConstantE* instr) {
1749   __ li(ToRegister(instr->result()), Operand(instr->value()));
1750 }
1751
1752
1753 void LCodeGen::DoConstantT(LConstantT* instr) {
1754   Handle<Object> object = instr->value(isolate());
1755   AllowDeferredHandleDereference smi_check;
1756   __ li(ToRegister(instr->result()), object);
1757 }
1758
1759
1760 void LCodeGen::DoMapEnumLength(LMapEnumLength* instr) {
1761   Register result = ToRegister(instr->result());
1762   Register map = ToRegister(instr->value());
1763   __ EnumLength(result, map);
1764 }
1765
1766
1767 void LCodeGen::DoDateField(LDateField* instr) {
1768   Register object = ToRegister(instr->date());
1769   Register result = ToRegister(instr->result());
1770   Register scratch = ToRegister(instr->temp());
1771   Smi* index = instr->index();
1772   Label runtime, done;
1773   ASSERT(object.is(a0));
1774   ASSERT(result.is(v0));
1775   ASSERT(!scratch.is(scratch0()));
1776   ASSERT(!scratch.is(object));
1777
1778   __ SmiTst(object, at);
1779   DeoptimizeIf(eq, instr->environment(), at, Operand(zero_reg));
1780   __ GetObjectType(object, scratch, scratch);
1781   DeoptimizeIf(ne, instr->environment(), scratch, Operand(JS_DATE_TYPE));
1782
1783   if (index->value() == 0) {
1784     __ lw(result, FieldMemOperand(object, JSDate::kValueOffset));
1785   } else {
1786     if (index->value() < JSDate::kFirstUncachedField) {
1787       ExternalReference stamp = ExternalReference::date_cache_stamp(isolate());
1788       __ li(scratch, Operand(stamp));
1789       __ lw(scratch, MemOperand(scratch));
1790       __ lw(scratch0(), FieldMemOperand(object, JSDate::kCacheStampOffset));
1791       __ Branch(&runtime, ne, scratch, Operand(scratch0()));
1792       __ lw(result, FieldMemOperand(object, JSDate::kValueOffset +
1793                                             kPointerSize * index->value()));
1794       __ jmp(&done);
1795     }
1796     __ bind(&runtime);
1797     __ PrepareCallCFunction(2, scratch);
1798     __ li(a1, Operand(index));
1799     __ CallCFunction(ExternalReference::get_date_field_function(isolate()), 2);
1800     __ bind(&done);
1801   }
1802 }
1803
1804
1805 MemOperand LCodeGen::BuildSeqStringOperand(Register string,
1806                                            LOperand* index,
1807                                            String::Encoding encoding) {
1808   if (index->IsConstantOperand()) {
1809     int offset = ToInteger32(LConstantOperand::cast(index));
1810     if (encoding == String::TWO_BYTE_ENCODING) {
1811       offset *= kUC16Size;
1812     }
1813     STATIC_ASSERT(kCharSize == 1);
1814     return FieldMemOperand(string, SeqString::kHeaderSize + offset);
1815   }
1816   Register scratch = scratch0();
1817   ASSERT(!scratch.is(string));
1818   ASSERT(!scratch.is(ToRegister(index)));
1819   if (encoding == String::ONE_BYTE_ENCODING) {
1820     __ Addu(scratch, string, ToRegister(index));
1821   } else {
1822     STATIC_ASSERT(kUC16Size == 2);
1823     __ sll(scratch, ToRegister(index), 1);
1824     __ Addu(scratch, string, scratch);
1825   }
1826   return FieldMemOperand(scratch, SeqString::kHeaderSize);
1827 }
1828
1829
1830 void LCodeGen::DoSeqStringGetChar(LSeqStringGetChar* instr) {
1831   String::Encoding encoding = instr->hydrogen()->encoding();
1832   Register string = ToRegister(instr->string());
1833   Register result = ToRegister(instr->result());
1834
1835   if (FLAG_debug_code) {
1836     Register scratch = scratch0();
1837     __ lw(scratch, FieldMemOperand(string, HeapObject::kMapOffset));
1838     __ lbu(scratch, FieldMemOperand(scratch, Map::kInstanceTypeOffset));
1839
1840     __ And(scratch, scratch,
1841            Operand(kStringRepresentationMask | kStringEncodingMask));
1842     static const uint32_t one_byte_seq_type = kSeqStringTag | kOneByteStringTag;
1843     static const uint32_t two_byte_seq_type = kSeqStringTag | kTwoByteStringTag;
1844     __ Subu(at, scratch, Operand(encoding == String::ONE_BYTE_ENCODING
1845                                 ? one_byte_seq_type : two_byte_seq_type));
1846     __ Check(eq, kUnexpectedStringType, at, Operand(zero_reg));
1847   }
1848
1849   MemOperand operand = BuildSeqStringOperand(string, instr->index(), encoding);
1850   if (encoding == String::ONE_BYTE_ENCODING) {
1851     __ lbu(result, operand);
1852   } else {
1853     __ lhu(result, operand);
1854   }
1855 }
1856
1857
1858 void LCodeGen::DoSeqStringSetChar(LSeqStringSetChar* instr) {
1859   String::Encoding encoding = instr->hydrogen()->encoding();
1860   Register string = ToRegister(instr->string());
1861   Register value = ToRegister(instr->value());
1862
1863   if (FLAG_debug_code) {
1864     Register scratch = scratch0();
1865     Register index = ToRegister(instr->index());
1866     static const uint32_t one_byte_seq_type = kSeqStringTag | kOneByteStringTag;
1867     static const uint32_t two_byte_seq_type = kSeqStringTag | kTwoByteStringTag;
1868     int encoding_mask =
1869         instr->hydrogen()->encoding() == String::ONE_BYTE_ENCODING
1870         ? one_byte_seq_type : two_byte_seq_type;
1871     __ EmitSeqStringSetCharCheck(string, index, value, scratch, encoding_mask);
1872   }
1873
1874   MemOperand operand = BuildSeqStringOperand(string, instr->index(), encoding);
1875   if (encoding == String::ONE_BYTE_ENCODING) {
1876     __ sb(value, operand);
1877   } else {
1878     __ sh(value, operand);
1879   }
1880 }
1881
1882
1883 void LCodeGen::DoAddI(LAddI* instr) {
1884   LOperand* left = instr->left();
1885   LOperand* right = instr->right();
1886   LOperand* result = instr->result();
1887   bool can_overflow = instr->hydrogen()->CheckFlag(HValue::kCanOverflow);
1888
1889   if (!can_overflow) {
1890     if (right->IsStackSlot()) {
1891       Register right_reg = EmitLoadRegister(right, at);
1892       __ Addu(ToRegister(result), ToRegister(left), Operand(right_reg));
1893     } else {
1894       ASSERT(right->IsRegister() || right->IsConstantOperand());
1895       __ Addu(ToRegister(result), ToRegister(left), ToOperand(right));
1896     }
1897   } else {  // can_overflow.
1898     Register overflow = scratch0();
1899     Register scratch = scratch1();
1900     if (right->IsStackSlot() ||
1901         right->IsConstantOperand()) {
1902       Register right_reg = EmitLoadRegister(right, scratch);
1903       __ AdduAndCheckForOverflow(ToRegister(result),
1904                                  ToRegister(left),
1905                                  right_reg,
1906                                  overflow);  // Reg at also used as scratch.
1907     } else {
1908       ASSERT(right->IsRegister());
1909       // Due to overflow check macros not supporting constant operands,
1910       // handling the IsConstantOperand case was moved to prev if clause.
1911       __ AdduAndCheckForOverflow(ToRegister(result),
1912                                  ToRegister(left),
1913                                  ToRegister(right),
1914                                  overflow);  // Reg at also used as scratch.
1915     }
1916     DeoptimizeIf(lt, instr->environment(), overflow, Operand(zero_reg));
1917   }
1918 }
1919
1920
1921 void LCodeGen::DoMathMinMax(LMathMinMax* instr) {
1922   LOperand* left = instr->left();
1923   LOperand* right = instr->right();
1924   HMathMinMax::Operation operation = instr->hydrogen()->operation();
1925   Condition condition = (operation == HMathMinMax::kMathMin) ? le : ge;
1926   if (instr->hydrogen()->representation().IsSmiOrInteger32()) {
1927     Register left_reg = ToRegister(left);
1928     Register right_reg = EmitLoadRegister(right, scratch0());
1929     Register result_reg = ToRegister(instr->result());
1930     Label return_right, done;
1931     Register scratch = scratch1();
1932     __ Slt(scratch, left_reg, Operand(right_reg));
1933     if (condition == ge) {
1934      __  Movz(result_reg, left_reg, scratch);
1935      __  Movn(result_reg, right_reg, scratch);
1936     } else {
1937      ASSERT(condition == le);
1938      __  Movn(result_reg, left_reg, scratch);
1939      __  Movz(result_reg, right_reg, scratch);
1940     }
1941   } else {
1942     ASSERT(instr->hydrogen()->representation().IsDouble());
1943     FPURegister left_reg = ToDoubleRegister(left);
1944     FPURegister right_reg = ToDoubleRegister(right);
1945     FPURegister result_reg = ToDoubleRegister(instr->result());
1946     Label check_nan_left, check_zero, return_left, return_right, done;
1947     __ BranchF(&check_zero, &check_nan_left, eq, left_reg, right_reg);
1948     __ BranchF(&return_left, NULL, condition, left_reg, right_reg);
1949     __ Branch(&return_right);
1950
1951     __ bind(&check_zero);
1952     // left == right != 0.
1953     __ BranchF(&return_left, NULL, ne, left_reg, kDoubleRegZero);
1954     // At this point, both left and right are either 0 or -0.
1955     if (operation == HMathMinMax::kMathMin) {
1956       __ neg_d(left_reg, left_reg);
1957       __ sub_d(result_reg, left_reg, right_reg);
1958       __ neg_d(result_reg, result_reg);
1959     } else {
1960       __ add_d(result_reg, left_reg, right_reg);
1961     }
1962     __ Branch(&done);
1963
1964     __ bind(&check_nan_left);
1965     // left == NaN.
1966     __ BranchF(NULL, &return_left, eq, left_reg, left_reg);
1967     __ bind(&return_right);
1968     if (!right_reg.is(result_reg)) {
1969       __ mov_d(result_reg, right_reg);
1970     }
1971     __ Branch(&done);
1972
1973     __ bind(&return_left);
1974     if (!left_reg.is(result_reg)) {
1975       __ mov_d(result_reg, left_reg);
1976     }
1977     __ bind(&done);
1978   }
1979 }
1980
1981
1982 void LCodeGen::DoArithmeticD(LArithmeticD* instr) {
1983   DoubleRegister left = ToDoubleRegister(instr->left());
1984   DoubleRegister right = ToDoubleRegister(instr->right());
1985   DoubleRegister result = ToDoubleRegister(instr->result());
1986   switch (instr->op()) {
1987     case Token::ADD:
1988       __ add_d(result, left, right);
1989       break;
1990     case Token::SUB:
1991       __ sub_d(result, left, right);
1992       break;
1993     case Token::MUL:
1994       __ mul_d(result, left, right);
1995       break;
1996     case Token::DIV:
1997       __ div_d(result, left, right);
1998       break;
1999     case Token::MOD: {
2000       // Save a0-a3 on the stack.
2001       RegList saved_regs = a0.bit() | a1.bit() | a2.bit() | a3.bit();
2002       __ MultiPush(saved_regs);
2003
2004       __ PrepareCallCFunction(0, 2, scratch0());
2005       __ MovToFloatParameters(left, right);
2006       __ CallCFunction(
2007           ExternalReference::mod_two_doubles_operation(isolate()),
2008           0, 2);
2009       // Move the result in the double result register.
2010       __ MovFromFloatResult(result);
2011
2012       // Restore saved register.
2013       __ MultiPop(saved_regs);
2014       break;
2015     }
2016     default:
2017       UNREACHABLE();
2018       break;
2019   }
2020 }
2021
2022
2023 void LCodeGen::DoArithmeticT(LArithmeticT* instr) {
2024   ASSERT(ToRegister(instr->context()).is(cp));
2025   ASSERT(ToRegister(instr->left()).is(a1));
2026   ASSERT(ToRegister(instr->right()).is(a0));
2027   ASSERT(ToRegister(instr->result()).is(v0));
2028
2029   BinaryOpICStub stub(isolate(), instr->op(), NO_OVERWRITE);
2030   CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr);
2031   // Other arch use a nop here, to signal that there is no inlined
2032   // patchable code. Mips does not need the nop, since our marker
2033   // instruction (andi zero_reg) will never be used in normal code.
2034 }
2035
2036
2037 template<class InstrType>
2038 void LCodeGen::EmitBranch(InstrType instr,
2039                           Condition condition,
2040                           Register src1,
2041                           const Operand& src2) {
2042   int left_block = instr->TrueDestination(chunk_);
2043   int right_block = instr->FalseDestination(chunk_);
2044
2045   int next_block = GetNextEmittedBlock();
2046   if (right_block == left_block || condition == al) {
2047     EmitGoto(left_block);
2048   } else if (left_block == next_block) {
2049     __ Branch(chunk_->GetAssemblyLabel(right_block),
2050               NegateCondition(condition), src1, src2);
2051   } else if (right_block == next_block) {
2052     __ Branch(chunk_->GetAssemblyLabel(left_block), condition, src1, src2);
2053   } else {
2054     __ Branch(chunk_->GetAssemblyLabel(left_block), condition, src1, src2);
2055     __ Branch(chunk_->GetAssemblyLabel(right_block));
2056   }
2057 }
2058
2059
2060 template<class InstrType>
2061 void LCodeGen::EmitBranchF(InstrType instr,
2062                            Condition condition,
2063                            FPURegister src1,
2064                            FPURegister src2) {
2065   int right_block = instr->FalseDestination(chunk_);
2066   int left_block = instr->TrueDestination(chunk_);
2067
2068   int next_block = GetNextEmittedBlock();
2069   if (right_block == left_block) {
2070     EmitGoto(left_block);
2071   } else if (left_block == next_block) {
2072     __ BranchF(chunk_->GetAssemblyLabel(right_block), NULL,
2073                NegateCondition(condition), src1, src2);
2074   } else if (right_block == next_block) {
2075     __ BranchF(chunk_->GetAssemblyLabel(left_block), NULL,
2076                condition, src1, src2);
2077   } else {
2078     __ BranchF(chunk_->GetAssemblyLabel(left_block), NULL,
2079                condition, src1, src2);
2080     __ Branch(chunk_->GetAssemblyLabel(right_block));
2081   }
2082 }
2083
2084
2085 template<class InstrType>
2086 void LCodeGen::EmitFalseBranch(InstrType instr,
2087                                Condition condition,
2088                                Register src1,
2089                                const Operand& src2) {
2090   int false_block = instr->FalseDestination(chunk_);
2091   __ Branch(chunk_->GetAssemblyLabel(false_block), condition, src1, src2);
2092 }
2093
2094
2095 template<class InstrType>
2096 void LCodeGen::EmitFalseBranchF(InstrType instr,
2097                                 Condition condition,
2098                                 FPURegister src1,
2099                                 FPURegister src2) {
2100   int false_block = instr->FalseDestination(chunk_);
2101   __ BranchF(chunk_->GetAssemblyLabel(false_block), NULL,
2102              condition, src1, src2);
2103 }
2104
2105
2106 void LCodeGen::DoDebugBreak(LDebugBreak* instr) {
2107   __ stop("LDebugBreak");
2108 }
2109
2110
2111 void LCodeGen::DoBranch(LBranch* instr) {
2112   Representation r = instr->hydrogen()->value()->representation();
2113   if (r.IsInteger32() || r.IsSmi()) {
2114     ASSERT(!info()->IsStub());
2115     Register reg = ToRegister(instr->value());
2116     EmitBranch(instr, ne, reg, Operand(zero_reg));
2117   } else if (r.IsDouble()) {
2118     ASSERT(!info()->IsStub());
2119     DoubleRegister reg = ToDoubleRegister(instr->value());
2120     // Test the double value. Zero and NaN are false.
2121     EmitBranchF(instr, nue, reg, kDoubleRegZero);
2122   } else {
2123     ASSERT(r.IsTagged());
2124     Register reg = ToRegister(instr->value());
2125     HType type = instr->hydrogen()->value()->type();
2126     if (type.IsBoolean()) {
2127       ASSERT(!info()->IsStub());
2128       __ LoadRoot(at, Heap::kTrueValueRootIndex);
2129       EmitBranch(instr, eq, reg, Operand(at));
2130     } else if (type.IsSmi()) {
2131       ASSERT(!info()->IsStub());
2132       EmitBranch(instr, ne, reg, Operand(zero_reg));
2133     } else if (type.IsJSArray()) {
2134       ASSERT(!info()->IsStub());
2135       EmitBranch(instr, al, zero_reg, Operand(zero_reg));
2136     } else if (type.IsHeapNumber()) {
2137       ASSERT(!info()->IsStub());
2138       DoubleRegister dbl_scratch = double_scratch0();
2139       __ ldc1(dbl_scratch, FieldMemOperand(reg, HeapNumber::kValueOffset));
2140       // Test the double value. Zero and NaN are false.
2141       EmitBranchF(instr, nue, dbl_scratch, kDoubleRegZero);
2142     } else if (type.IsString()) {
2143       ASSERT(!info()->IsStub());
2144       __ lw(at, FieldMemOperand(reg, String::kLengthOffset));
2145       EmitBranch(instr, ne, at, Operand(zero_reg));
2146     } else {
2147       ToBooleanStub::Types expected = instr->hydrogen()->expected_input_types();
2148       // Avoid deopts in the case where we've never executed this path before.
2149       if (expected.IsEmpty()) expected = ToBooleanStub::Types::Generic();
2150
2151       if (expected.Contains(ToBooleanStub::UNDEFINED)) {
2152         // undefined -> false.
2153         __ LoadRoot(at, Heap::kUndefinedValueRootIndex);
2154         __ Branch(instr->FalseLabel(chunk_), eq, reg, Operand(at));
2155       }
2156       if (expected.Contains(ToBooleanStub::BOOLEAN)) {
2157         // Boolean -> its value.
2158         __ LoadRoot(at, Heap::kTrueValueRootIndex);
2159         __ Branch(instr->TrueLabel(chunk_), eq, reg, Operand(at));
2160         __ LoadRoot(at, Heap::kFalseValueRootIndex);
2161         __ Branch(instr->FalseLabel(chunk_), eq, reg, Operand(at));
2162       }
2163       if (expected.Contains(ToBooleanStub::NULL_TYPE)) {
2164         // 'null' -> false.
2165         __ LoadRoot(at, Heap::kNullValueRootIndex);
2166         __ Branch(instr->FalseLabel(chunk_), eq, reg, Operand(at));
2167       }
2168
2169       if (expected.Contains(ToBooleanStub::SMI)) {
2170         // Smis: 0 -> false, all other -> true.
2171         __ Branch(instr->FalseLabel(chunk_), eq, reg, Operand(zero_reg));
2172         __ JumpIfSmi(reg, instr->TrueLabel(chunk_));
2173       } else if (expected.NeedsMap()) {
2174         // If we need a map later and have a Smi -> deopt.
2175         __ SmiTst(reg, at);
2176         DeoptimizeIf(eq, instr->environment(), at, Operand(zero_reg));
2177       }
2178
2179       const Register map = scratch0();
2180       if (expected.NeedsMap()) {
2181         __ lw(map, FieldMemOperand(reg, HeapObject::kMapOffset));
2182         if (expected.CanBeUndetectable()) {
2183           // Undetectable -> false.
2184           __ lbu(at, FieldMemOperand(map, Map::kBitFieldOffset));
2185           __ And(at, at, Operand(1 << Map::kIsUndetectable));
2186           __ Branch(instr->FalseLabel(chunk_), ne, at, Operand(zero_reg));
2187         }
2188       }
2189
2190       if (expected.Contains(ToBooleanStub::SPEC_OBJECT)) {
2191         // spec object -> true.
2192         __ lbu(at, FieldMemOperand(map, Map::kInstanceTypeOffset));
2193         __ Branch(instr->TrueLabel(chunk_),
2194                   ge, at, Operand(FIRST_SPEC_OBJECT_TYPE));
2195       }
2196
2197       if (expected.Contains(ToBooleanStub::STRING)) {
2198         // String value -> false iff empty.
2199         Label not_string;
2200         __ lbu(at, FieldMemOperand(map, Map::kInstanceTypeOffset));
2201         __ Branch(&not_string, ge , at, Operand(FIRST_NONSTRING_TYPE));
2202         __ lw(at, FieldMemOperand(reg, String::kLengthOffset));
2203         __ Branch(instr->TrueLabel(chunk_), ne, at, Operand(zero_reg));
2204         __ Branch(instr->FalseLabel(chunk_));
2205         __ bind(&not_string);
2206       }
2207
2208       if (expected.Contains(ToBooleanStub::SYMBOL)) {
2209         // Symbol value -> true.
2210         const Register scratch = scratch1();
2211         __ lbu(scratch, FieldMemOperand(map, Map::kInstanceTypeOffset));
2212         __ Branch(instr->TrueLabel(chunk_), eq, scratch, Operand(SYMBOL_TYPE));
2213       }
2214
2215       if (expected.Contains(ToBooleanStub::HEAP_NUMBER)) {
2216         // heap number -> false iff +0, -0, or NaN.
2217         DoubleRegister dbl_scratch = double_scratch0();
2218         Label not_heap_number;
2219         __ LoadRoot(at, Heap::kHeapNumberMapRootIndex);
2220         __ Branch(&not_heap_number, ne, map, Operand(at));
2221         __ ldc1(dbl_scratch, FieldMemOperand(reg, HeapNumber::kValueOffset));
2222         __ BranchF(instr->TrueLabel(chunk_), instr->FalseLabel(chunk_),
2223                    ne, dbl_scratch, kDoubleRegZero);
2224         // Falls through if dbl_scratch == 0.
2225         __ Branch(instr->FalseLabel(chunk_));
2226         __ bind(&not_heap_number);
2227       }
2228
2229       if (!expected.IsGeneric()) {
2230         // We've seen something for the first time -> deopt.
2231         // This can only happen if we are not generic already.
2232         DeoptimizeIf(al, instr->environment(), zero_reg, Operand(zero_reg));
2233       }
2234     }
2235   }
2236 }
2237
2238
2239 void LCodeGen::EmitGoto(int block) {
2240   if (!IsNextEmittedBlock(block)) {
2241     __ jmp(chunk_->GetAssemblyLabel(LookupDestination(block)));
2242   }
2243 }
2244
2245
2246 void LCodeGen::DoGoto(LGoto* instr) {
2247   EmitGoto(instr->block_id());
2248 }
2249
2250
2251 Condition LCodeGen::TokenToCondition(Token::Value op, bool is_unsigned) {
2252   Condition cond = kNoCondition;
2253   switch (op) {
2254     case Token::EQ:
2255     case Token::EQ_STRICT:
2256       cond = eq;
2257       break;
2258     case Token::NE:
2259     case Token::NE_STRICT:
2260       cond = ne;
2261       break;
2262     case Token::LT:
2263       cond = is_unsigned ? lo : lt;
2264       break;
2265     case Token::GT:
2266       cond = is_unsigned ? hi : gt;
2267       break;
2268     case Token::LTE:
2269       cond = is_unsigned ? ls : le;
2270       break;
2271     case Token::GTE:
2272       cond = is_unsigned ? hs : ge;
2273       break;
2274     case Token::IN:
2275     case Token::INSTANCEOF:
2276     default:
2277       UNREACHABLE();
2278   }
2279   return cond;
2280 }
2281
2282
2283 void LCodeGen::DoCompareNumericAndBranch(LCompareNumericAndBranch* instr) {
2284   LOperand* left = instr->left();
2285   LOperand* right = instr->right();
2286   bool is_unsigned =
2287       instr->hydrogen()->left()->CheckFlag(HInstruction::kUint32) ||
2288       instr->hydrogen()->right()->CheckFlag(HInstruction::kUint32);
2289   Condition cond = TokenToCondition(instr->op(), is_unsigned);
2290
2291   if (left->IsConstantOperand() && right->IsConstantOperand()) {
2292     // We can statically evaluate the comparison.
2293     double left_val = ToDouble(LConstantOperand::cast(left));
2294     double right_val = ToDouble(LConstantOperand::cast(right));
2295     int next_block = EvalComparison(instr->op(), left_val, right_val) ?
2296         instr->TrueDestination(chunk_) : instr->FalseDestination(chunk_);
2297     EmitGoto(next_block);
2298   } else {
2299     if (instr->is_double()) {
2300       // Compare left and right as doubles and load the
2301       // resulting flags into the normal status register.
2302       FPURegister left_reg = ToDoubleRegister(left);
2303       FPURegister right_reg = ToDoubleRegister(right);
2304
2305       // If a NaN is involved, i.e. the result is unordered,
2306       // jump to false block label.
2307       __ BranchF(NULL, instr->FalseLabel(chunk_), eq,
2308                  left_reg, right_reg);
2309
2310       EmitBranchF(instr, cond, left_reg, right_reg);
2311     } else {
2312       Register cmp_left;
2313       Operand cmp_right = Operand(0);
2314
2315       if (right->IsConstantOperand()) {
2316         int32_t value = ToInteger32(LConstantOperand::cast(right));
2317         if (instr->hydrogen_value()->representation().IsSmi()) {
2318           cmp_left = ToRegister(left);
2319           cmp_right = Operand(Smi::FromInt(value));
2320         } else {
2321           cmp_left = ToRegister(left);
2322           cmp_right = Operand(value);
2323         }
2324       } else if (left->IsConstantOperand()) {
2325         int32_t value = ToInteger32(LConstantOperand::cast(left));
2326         if (instr->hydrogen_value()->representation().IsSmi()) {
2327            cmp_left = ToRegister(right);
2328            cmp_right = Operand(Smi::FromInt(value));
2329         } else {
2330           cmp_left = ToRegister(right);
2331           cmp_right = Operand(value);
2332         }
2333         // We commuted the operands, so commute the condition.
2334         cond = CommuteCondition(cond);
2335       } else {
2336         cmp_left = ToRegister(left);
2337         cmp_right = Operand(ToRegister(right));
2338       }
2339
2340       EmitBranch(instr, cond, cmp_left, cmp_right);
2341     }
2342   }
2343 }
2344
2345
2346 void LCodeGen::DoCmpObjectEqAndBranch(LCmpObjectEqAndBranch* instr) {
2347   Register left = ToRegister(instr->left());
2348   Register right = ToRegister(instr->right());
2349
2350   EmitBranch(instr, eq, left, Operand(right));
2351 }
2352
2353
2354 void LCodeGen::DoCmpHoleAndBranch(LCmpHoleAndBranch* instr) {
2355   if (instr->hydrogen()->representation().IsTagged()) {
2356     Register input_reg = ToRegister(instr->object());
2357     __ li(at, Operand(factory()->the_hole_value()));
2358     EmitBranch(instr, eq, input_reg, Operand(at));
2359     return;
2360   }
2361
2362   DoubleRegister input_reg = ToDoubleRegister(instr->object());
2363   EmitFalseBranchF(instr, eq, input_reg, input_reg);
2364
2365   Register scratch = scratch0();
2366   __ FmoveHigh(scratch, input_reg);
2367   EmitBranch(instr, eq, scratch, Operand(kHoleNanUpper32));
2368 }
2369
2370
2371 void LCodeGen::DoCompareMinusZeroAndBranch(LCompareMinusZeroAndBranch* instr) {
2372   Representation rep = instr->hydrogen()->value()->representation();
2373   ASSERT(!rep.IsInteger32());
2374   Register scratch = ToRegister(instr->temp());
2375
2376   if (rep.IsDouble()) {
2377     DoubleRegister value = ToDoubleRegister(instr->value());
2378     EmitFalseBranchF(instr, ne, value, kDoubleRegZero);
2379     __ FmoveHigh(scratch, value);
2380     __ li(at, 0x80000000);
2381   } else {
2382     Register value = ToRegister(instr->value());
2383     __ CheckMap(value,
2384                 scratch,
2385                 Heap::kHeapNumberMapRootIndex,
2386                 instr->FalseLabel(chunk()),
2387                 DO_SMI_CHECK);
2388     __ lw(scratch, FieldMemOperand(value, HeapNumber::kExponentOffset));
2389     EmitFalseBranch(instr, ne, scratch, Operand(0x80000000));
2390     __ lw(scratch, FieldMemOperand(value, HeapNumber::kMantissaOffset));
2391     __ mov(at, zero_reg);
2392   }
2393   EmitBranch(instr, eq, scratch, Operand(at));
2394 }
2395
2396
2397 Condition LCodeGen::EmitIsObject(Register input,
2398                                  Register temp1,
2399                                  Register temp2,
2400                                  Label* is_not_object,
2401                                  Label* is_object) {
2402   __ JumpIfSmi(input, is_not_object);
2403
2404   __ LoadRoot(temp2, Heap::kNullValueRootIndex);
2405   __ Branch(is_object, eq, input, Operand(temp2));
2406
2407   // Load map.
2408   __ lw(temp1, FieldMemOperand(input, HeapObject::kMapOffset));
2409   // Undetectable objects behave like undefined.
2410   __ lbu(temp2, FieldMemOperand(temp1, Map::kBitFieldOffset));
2411   __ And(temp2, temp2, Operand(1 << Map::kIsUndetectable));
2412   __ Branch(is_not_object, ne, temp2, Operand(zero_reg));
2413
2414   // Load instance type and check that it is in object type range.
2415   __ lbu(temp2, FieldMemOperand(temp1, Map::kInstanceTypeOffset));
2416   __ Branch(is_not_object,
2417             lt, temp2, Operand(FIRST_NONCALLABLE_SPEC_OBJECT_TYPE));
2418
2419   return le;
2420 }
2421
2422
2423 void LCodeGen::DoIsObjectAndBranch(LIsObjectAndBranch* instr) {
2424   Register reg = ToRegister(instr->value());
2425   Register temp1 = ToRegister(instr->temp());
2426   Register temp2 = scratch0();
2427
2428   Condition true_cond =
2429       EmitIsObject(reg, temp1, temp2,
2430           instr->FalseLabel(chunk_), instr->TrueLabel(chunk_));
2431
2432   EmitBranch(instr, true_cond, temp2,
2433              Operand(LAST_NONCALLABLE_SPEC_OBJECT_TYPE));
2434 }
2435
2436
2437 Condition LCodeGen::EmitIsString(Register input,
2438                                  Register temp1,
2439                                  Label* is_not_string,
2440                                  SmiCheck check_needed = INLINE_SMI_CHECK) {
2441   if (check_needed == INLINE_SMI_CHECK) {
2442     __ JumpIfSmi(input, is_not_string);
2443   }
2444   __ GetObjectType(input, temp1, temp1);
2445
2446   return lt;
2447 }
2448
2449
2450 void LCodeGen::DoIsStringAndBranch(LIsStringAndBranch* instr) {
2451   Register reg = ToRegister(instr->value());
2452   Register temp1 = ToRegister(instr->temp());
2453
2454   SmiCheck check_needed =
2455       instr->hydrogen()->value()->type().IsHeapObject()
2456           ? OMIT_SMI_CHECK : INLINE_SMI_CHECK;
2457   Condition true_cond =
2458       EmitIsString(reg, temp1, instr->FalseLabel(chunk_), check_needed);
2459
2460   EmitBranch(instr, true_cond, temp1,
2461              Operand(FIRST_NONSTRING_TYPE));
2462 }
2463
2464
2465 void LCodeGen::DoIsSmiAndBranch(LIsSmiAndBranch* instr) {
2466   Register input_reg = EmitLoadRegister(instr->value(), at);
2467   __ And(at, input_reg, kSmiTagMask);
2468   EmitBranch(instr, eq, at, Operand(zero_reg));
2469 }
2470
2471
2472 void LCodeGen::DoIsUndetectableAndBranch(LIsUndetectableAndBranch* instr) {
2473   Register input = ToRegister(instr->value());
2474   Register temp = ToRegister(instr->temp());
2475
2476   if (!instr->hydrogen()->value()->type().IsHeapObject()) {
2477     __ JumpIfSmi(input, instr->FalseLabel(chunk_));
2478   }
2479   __ lw(temp, FieldMemOperand(input, HeapObject::kMapOffset));
2480   __ lbu(temp, FieldMemOperand(temp, Map::kBitFieldOffset));
2481   __ And(at, temp, Operand(1 << Map::kIsUndetectable));
2482   EmitBranch(instr, ne, at, Operand(zero_reg));
2483 }
2484
2485
2486 static Condition ComputeCompareCondition(Token::Value op) {
2487   switch (op) {
2488     case Token::EQ_STRICT:
2489     case Token::EQ:
2490       return eq;
2491     case Token::LT:
2492       return lt;
2493     case Token::GT:
2494       return gt;
2495     case Token::LTE:
2496       return le;
2497     case Token::GTE:
2498       return ge;
2499     default:
2500       UNREACHABLE();
2501       return kNoCondition;
2502   }
2503 }
2504
2505
2506 void LCodeGen::DoStringCompareAndBranch(LStringCompareAndBranch* instr) {
2507   ASSERT(ToRegister(instr->context()).is(cp));
2508   Token::Value op = instr->op();
2509
2510   Handle<Code> ic = CompareIC::GetUninitialized(isolate(), op);
2511   CallCode(ic, RelocInfo::CODE_TARGET, instr);
2512
2513   Condition condition = ComputeCompareCondition(op);
2514
2515   EmitBranch(instr, condition, v0, Operand(zero_reg));
2516 }
2517
2518
2519 static InstanceType TestType(HHasInstanceTypeAndBranch* instr) {
2520   InstanceType from = instr->from();
2521   InstanceType to = instr->to();
2522   if (from == FIRST_TYPE) return to;
2523   ASSERT(from == to || to == LAST_TYPE);
2524   return from;
2525 }
2526
2527
2528 static Condition BranchCondition(HHasInstanceTypeAndBranch* instr) {
2529   InstanceType from = instr->from();
2530   InstanceType to = instr->to();
2531   if (from == to) return eq;
2532   if (to == LAST_TYPE) return hs;
2533   if (from == FIRST_TYPE) return ls;
2534   UNREACHABLE();
2535   return eq;
2536 }
2537
2538
2539 void LCodeGen::DoHasInstanceTypeAndBranch(LHasInstanceTypeAndBranch* instr) {
2540   Register scratch = scratch0();
2541   Register input = ToRegister(instr->value());
2542
2543   if (!instr->hydrogen()->value()->type().IsHeapObject()) {
2544     __ JumpIfSmi(input, instr->FalseLabel(chunk_));
2545   }
2546
2547   __ GetObjectType(input, scratch, scratch);
2548   EmitBranch(instr,
2549              BranchCondition(instr->hydrogen()),
2550              scratch,
2551              Operand(TestType(instr->hydrogen())));
2552 }
2553
2554
2555 void LCodeGen::DoGetCachedArrayIndex(LGetCachedArrayIndex* instr) {
2556   Register input = ToRegister(instr->value());
2557   Register result = ToRegister(instr->result());
2558
2559   __ AssertString(input);
2560
2561   __ lw(result, FieldMemOperand(input, String::kHashFieldOffset));
2562   __ IndexFromHash(result, result);
2563 }
2564
2565
2566 void LCodeGen::DoHasCachedArrayIndexAndBranch(
2567     LHasCachedArrayIndexAndBranch* instr) {
2568   Register input = ToRegister(instr->value());
2569   Register scratch = scratch0();
2570
2571   __ lw(scratch,
2572          FieldMemOperand(input, String::kHashFieldOffset));
2573   __ And(at, scratch, Operand(String::kContainsCachedArrayIndexMask));
2574   EmitBranch(instr, eq, at, Operand(zero_reg));
2575 }
2576
2577
2578 // Branches to a label or falls through with the answer in flags.  Trashes
2579 // the temp registers, but not the input.
2580 void LCodeGen::EmitClassOfTest(Label* is_true,
2581                                Label* is_false,
2582                                Handle<String>class_name,
2583                                Register input,
2584                                Register temp,
2585                                Register temp2) {
2586   ASSERT(!input.is(temp));
2587   ASSERT(!input.is(temp2));
2588   ASSERT(!temp.is(temp2));
2589
2590   __ JumpIfSmi(input, is_false);
2591
2592   if (class_name->IsOneByteEqualTo(STATIC_ASCII_VECTOR("Function"))) {
2593     // Assuming the following assertions, we can use the same compares to test
2594     // for both being a function type and being in the object type range.
2595     STATIC_ASSERT(NUM_OF_CALLABLE_SPEC_OBJECT_TYPES == 2);
2596     STATIC_ASSERT(FIRST_NONCALLABLE_SPEC_OBJECT_TYPE ==
2597                   FIRST_SPEC_OBJECT_TYPE + 1);
2598     STATIC_ASSERT(LAST_NONCALLABLE_SPEC_OBJECT_TYPE ==
2599                   LAST_SPEC_OBJECT_TYPE - 1);
2600     STATIC_ASSERT(LAST_SPEC_OBJECT_TYPE == LAST_TYPE);
2601
2602     __ GetObjectType(input, temp, temp2);
2603     __ Branch(is_false, lt, temp2, Operand(FIRST_SPEC_OBJECT_TYPE));
2604     __ Branch(is_true, eq, temp2, Operand(FIRST_SPEC_OBJECT_TYPE));
2605     __ Branch(is_true, eq, temp2, Operand(LAST_SPEC_OBJECT_TYPE));
2606   } else {
2607     // Faster code path to avoid two compares: subtract lower bound from the
2608     // actual type and do a signed compare with the width of the type range.
2609     __ GetObjectType(input, temp, temp2);
2610     __ Subu(temp2, temp2, Operand(FIRST_NONCALLABLE_SPEC_OBJECT_TYPE));
2611     __ Branch(is_false, gt, temp2, Operand(LAST_NONCALLABLE_SPEC_OBJECT_TYPE -
2612                                            FIRST_NONCALLABLE_SPEC_OBJECT_TYPE));
2613   }
2614
2615   // Now we are in the FIRST-LAST_NONCALLABLE_SPEC_OBJECT_TYPE range.
2616   // Check if the constructor in the map is a function.
2617   __ lw(temp, FieldMemOperand(temp, Map::kConstructorOffset));
2618
2619   // Objects with a non-function constructor have class 'Object'.
2620   __ GetObjectType(temp, temp2, temp2);
2621   if (class_name->IsOneByteEqualTo(STATIC_ASCII_VECTOR("Object"))) {
2622     __ Branch(is_true, ne, temp2, Operand(JS_FUNCTION_TYPE));
2623   } else {
2624     __ Branch(is_false, ne, temp2, Operand(JS_FUNCTION_TYPE));
2625   }
2626
2627   // temp now contains the constructor function. Grab the
2628   // instance class name from there.
2629   __ lw(temp, FieldMemOperand(temp, JSFunction::kSharedFunctionInfoOffset));
2630   __ lw(temp, FieldMemOperand(temp,
2631                                SharedFunctionInfo::kInstanceClassNameOffset));
2632   // The class name we are testing against is internalized since it's a literal.
2633   // The name in the constructor is internalized because of the way the context
2634   // is booted.  This routine isn't expected to work for random API-created
2635   // classes and it doesn't have to because you can't access it with natives
2636   // syntax.  Since both sides are internalized it is sufficient to use an
2637   // identity comparison.
2638
2639   // End with the address of this class_name instance in temp register.
2640   // On MIPS, the caller must do the comparison with Handle<String>class_name.
2641 }
2642
2643
2644 void LCodeGen::DoClassOfTestAndBranch(LClassOfTestAndBranch* instr) {
2645   Register input = ToRegister(instr->value());
2646   Register temp = scratch0();
2647   Register temp2 = ToRegister(instr->temp());
2648   Handle<String> class_name = instr->hydrogen()->class_name();
2649
2650   EmitClassOfTest(instr->TrueLabel(chunk_), instr->FalseLabel(chunk_),
2651                   class_name, input, temp, temp2);
2652
2653   EmitBranch(instr, eq, temp, Operand(class_name));
2654 }
2655
2656
2657 void LCodeGen::DoCmpMapAndBranch(LCmpMapAndBranch* instr) {
2658   Register reg = ToRegister(instr->value());
2659   Register temp = ToRegister(instr->temp());
2660
2661   __ lw(temp, FieldMemOperand(reg, HeapObject::kMapOffset));
2662   EmitBranch(instr, eq, temp, Operand(instr->map()));
2663 }
2664
2665
2666 void LCodeGen::DoInstanceOf(LInstanceOf* instr) {
2667   ASSERT(ToRegister(instr->context()).is(cp));
2668   Label true_label, done;
2669   ASSERT(ToRegister(instr->left()).is(a0));  // Object is in a0.
2670   ASSERT(ToRegister(instr->right()).is(a1));  // Function is in a1.
2671   Register result = ToRegister(instr->result());
2672   ASSERT(result.is(v0));
2673
2674   InstanceofStub stub(isolate(), InstanceofStub::kArgsInRegisters);
2675   CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr);
2676
2677   __ Branch(&true_label, eq, result, Operand(zero_reg));
2678   __ li(result, Operand(factory()->false_value()));
2679   __ Branch(&done);
2680   __ bind(&true_label);
2681   __ li(result, Operand(factory()->true_value()));
2682   __ bind(&done);
2683 }
2684
2685
2686 void LCodeGen::DoInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr) {
2687   class DeferredInstanceOfKnownGlobal V8_FINAL : public LDeferredCode {
2688    public:
2689     DeferredInstanceOfKnownGlobal(LCodeGen* codegen,
2690                                   LInstanceOfKnownGlobal* instr)
2691         : LDeferredCode(codegen), instr_(instr) { }
2692     virtual void Generate() V8_OVERRIDE {
2693       codegen()->DoDeferredInstanceOfKnownGlobal(instr_, &map_check_);
2694     }
2695     virtual LInstruction* instr() V8_OVERRIDE { return instr_; }
2696     Label* map_check() { return &map_check_; }
2697
2698    private:
2699     LInstanceOfKnownGlobal* instr_;
2700     Label map_check_;
2701   };
2702
2703   DeferredInstanceOfKnownGlobal* deferred;
2704   deferred = new(zone()) DeferredInstanceOfKnownGlobal(this, instr);
2705
2706   Label done, false_result;
2707   Register object = ToRegister(instr->value());
2708   Register temp = ToRegister(instr->temp());
2709   Register result = ToRegister(instr->result());
2710
2711   ASSERT(object.is(a0));
2712   ASSERT(result.is(v0));
2713
2714   // A Smi is not instance of anything.
2715   __ JumpIfSmi(object, &false_result);
2716
2717   // This is the inlined call site instanceof cache. The two occurences of the
2718   // hole value will be patched to the last map/result pair generated by the
2719   // instanceof stub.
2720   Label cache_miss;
2721   Register map = temp;
2722   __ lw(map, FieldMemOperand(object, HeapObject::kMapOffset));
2723
2724   Assembler::BlockTrampolinePoolScope block_trampoline_pool(masm_);
2725   __ bind(deferred->map_check());  // Label for calculating code patching.
2726   // We use Factory::the_hole_value() on purpose instead of loading from the
2727   // root array to force relocation to be able to later patch with
2728   // the cached map.
2729   Handle<Cell> cell = factory()->NewCell(factory()->the_hole_value());
2730   __ li(at, Operand(Handle<Object>(cell)));
2731   __ lw(at, FieldMemOperand(at, PropertyCell::kValueOffset));
2732   __ BranchShort(&cache_miss, ne, map, Operand(at));
2733   // We use Factory::the_hole_value() on purpose instead of loading from the
2734   // root array to force relocation to be able to later patch
2735   // with true or false. The distance from map check has to be constant.
2736   __ li(result, Operand(factory()->the_hole_value()), CONSTANT_SIZE);
2737   __ Branch(&done);
2738
2739   // The inlined call site cache did not match. Check null and string before
2740   // calling the deferred code.
2741   __ bind(&cache_miss);
2742   // Null is not instance of anything.
2743   __ LoadRoot(temp, Heap::kNullValueRootIndex);
2744   __ Branch(&false_result, eq, object, Operand(temp));
2745
2746   // String values is not instance of anything.
2747   Condition cc = __ IsObjectStringType(object, temp, temp);
2748   __ Branch(&false_result, cc, temp, Operand(zero_reg));
2749
2750   // Go to the deferred code.
2751   __ Branch(deferred->entry());
2752
2753   __ bind(&false_result);
2754   __ LoadRoot(result, Heap::kFalseValueRootIndex);
2755
2756   // Here result has either true or false. Deferred code also produces true or
2757   // false object.
2758   __ bind(deferred->exit());
2759   __ bind(&done);
2760 }
2761
2762
2763 void LCodeGen::DoDeferredInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr,
2764                                                Label* map_check) {
2765   Register result = ToRegister(instr->result());
2766   ASSERT(result.is(v0));
2767
2768   InstanceofStub::Flags flags = InstanceofStub::kNoFlags;
2769   flags = static_cast<InstanceofStub::Flags>(
2770       flags | InstanceofStub::kArgsInRegisters);
2771   flags = static_cast<InstanceofStub::Flags>(
2772       flags | InstanceofStub::kCallSiteInlineCheck);
2773   flags = static_cast<InstanceofStub::Flags>(
2774       flags | InstanceofStub::kReturnTrueFalseObject);
2775   InstanceofStub stub(isolate(), flags);
2776
2777   PushSafepointRegistersScope scope(this, Safepoint::kWithRegisters);
2778   LoadContextFromDeferred(instr->context());
2779
2780   // Get the temp register reserved by the instruction. This needs to be t0 as
2781   // its slot of the pushing of safepoint registers is used to communicate the
2782   // offset to the location of the map check.
2783   Register temp = ToRegister(instr->temp());
2784   ASSERT(temp.is(t0));
2785   __ li(InstanceofStub::right(), instr->function());
2786   static const int kAdditionalDelta = 7;
2787   int delta = masm_->InstructionsGeneratedSince(map_check) + kAdditionalDelta;
2788   Label before_push_delta;
2789   __ bind(&before_push_delta);
2790   {
2791     Assembler::BlockTrampolinePoolScope block_trampoline_pool(masm_);
2792     __ li(temp, Operand(delta * kPointerSize), CONSTANT_SIZE);
2793     __ StoreToSafepointRegisterSlot(temp, temp);
2794   }
2795   CallCodeGeneric(stub.GetCode(),
2796                   RelocInfo::CODE_TARGET,
2797                   instr,
2798                   RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS);
2799   LEnvironment* env = instr->GetDeferredLazyDeoptimizationEnvironment();
2800   safepoints_.RecordLazyDeoptimizationIndex(env->deoptimization_index());
2801   // Put the result value into the result register slot and
2802   // restore all registers.
2803   __ StoreToSafepointRegisterSlot(result, result);
2804 }
2805
2806
2807 void LCodeGen::DoCmpT(LCmpT* instr) {
2808   ASSERT(ToRegister(instr->context()).is(cp));
2809   Token::Value op = instr->op();
2810
2811   Handle<Code> ic = CompareIC::GetUninitialized(isolate(), op);
2812   CallCode(ic, RelocInfo::CODE_TARGET, instr);
2813   // On MIPS there is no need for a "no inlined smi code" marker (nop).
2814
2815   Condition condition = ComputeCompareCondition(op);
2816   // A minor optimization that relies on LoadRoot always emitting one
2817   // instruction.
2818   Assembler::BlockTrampolinePoolScope block_trampoline_pool(masm());
2819   Label done, check;
2820   __ Branch(USE_DELAY_SLOT, &done, condition, v0, Operand(zero_reg));
2821   __ bind(&check);
2822   __ LoadRoot(ToRegister(instr->result()), Heap::kTrueValueRootIndex);
2823   ASSERT_EQ(1, masm()->InstructionsGeneratedSince(&check));
2824   __ LoadRoot(ToRegister(instr->result()), Heap::kFalseValueRootIndex);
2825   __ bind(&done);
2826 }
2827
2828
2829 void LCodeGen::DoReturn(LReturn* instr) {
2830   if (FLAG_trace && info()->IsOptimizing()) {
2831     // Push the return value on the stack as the parameter.
2832     // Runtime::TraceExit returns its parameter in v0. We're leaving the code
2833     // managed by the register allocator and tearing down the frame, it's
2834     // safe to write to the context register.
2835     __ push(v0);
2836     __ lw(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
2837     __ CallRuntime(Runtime::kTraceExit, 1);
2838   }
2839   if (info()->saves_caller_doubles()) {
2840     RestoreCallerDoubles();
2841   }
2842   int no_frame_start = -1;
2843   if (NeedsEagerFrame()) {
2844     __ mov(sp, fp);
2845     no_frame_start = masm_->pc_offset();
2846     __ Pop(ra, fp);
2847   }
2848   if (instr->has_constant_parameter_count()) {
2849     int parameter_count = ToInteger32(instr->constant_parameter_count());
2850     int32_t sp_delta = (parameter_count + 1) * kPointerSize;
2851     if (sp_delta != 0) {
2852       __ Addu(sp, sp, Operand(sp_delta));
2853     }
2854   } else {
2855     Register reg = ToRegister(instr->parameter_count());
2856     // The argument count parameter is a smi
2857     __ SmiUntag(reg);
2858     __ sll(at, reg, kPointerSizeLog2);
2859     __ Addu(sp, sp, at);
2860   }
2861
2862   __ Jump(ra);
2863
2864   if (no_frame_start != -1) {
2865     info_->AddNoFrameRange(no_frame_start, masm_->pc_offset());
2866   }
2867 }
2868
2869
2870 void LCodeGen::DoLoadGlobalCell(LLoadGlobalCell* instr) {
2871   Register result = ToRegister(instr->result());
2872   __ li(at, Operand(Handle<Object>(instr->hydrogen()->cell().handle())));
2873   __ lw(result, FieldMemOperand(at, Cell::kValueOffset));
2874   if (instr->hydrogen()->RequiresHoleCheck()) {
2875     __ LoadRoot(at, Heap::kTheHoleValueRootIndex);
2876     DeoptimizeIf(eq, instr->environment(), result, Operand(at));
2877   }
2878 }
2879
2880
2881 void LCodeGen::DoLoadGlobalGeneric(LLoadGlobalGeneric* instr) {
2882   ASSERT(ToRegister(instr->context()).is(cp));
2883   ASSERT(ToRegister(instr->global_object()).is(a0));
2884   ASSERT(ToRegister(instr->result()).is(v0));
2885
2886   __ li(a2, Operand(instr->name()));
2887   ContextualMode mode = instr->for_typeof() ? NOT_CONTEXTUAL : CONTEXTUAL;
2888   Handle<Code> ic = LoadIC::initialize_stub(isolate(), mode);
2889   CallCode(ic, RelocInfo::CODE_TARGET, instr);
2890 }
2891
2892
2893 void LCodeGen::DoStoreGlobalCell(LStoreGlobalCell* instr) {
2894   Register value = ToRegister(instr->value());
2895   Register cell = scratch0();
2896
2897   // Load the cell.
2898   __ li(cell, Operand(instr->hydrogen()->cell().handle()));
2899
2900   // If the cell we are storing to contains the hole it could have
2901   // been deleted from the property dictionary. In that case, we need
2902   // to update the property details in the property dictionary to mark
2903   // it as no longer deleted.
2904   if (instr->hydrogen()->RequiresHoleCheck()) {
2905     // We use a temp to check the payload.
2906     Register payload = ToRegister(instr->temp());
2907     __ lw(payload, FieldMemOperand(cell, Cell::kValueOffset));
2908     __ LoadRoot(at, Heap::kTheHoleValueRootIndex);
2909     DeoptimizeIf(eq, instr->environment(), payload, Operand(at));
2910   }
2911
2912   // Store the value.
2913   __ sw(value, FieldMemOperand(cell, Cell::kValueOffset));
2914   // Cells are always rescanned, so no write barrier here.
2915 }
2916
2917
2918
2919 void LCodeGen::DoLoadContextSlot(LLoadContextSlot* instr) {
2920   Register context = ToRegister(instr->context());
2921   Register result = ToRegister(instr->result());
2922
2923   __ lw(result, ContextOperand(context, instr->slot_index()));
2924   if (instr->hydrogen()->RequiresHoleCheck()) {
2925     __ LoadRoot(at, Heap::kTheHoleValueRootIndex);
2926
2927     if (instr->hydrogen()->DeoptimizesOnHole()) {
2928       DeoptimizeIf(eq, instr->environment(), result, Operand(at));
2929     } else {
2930       Label is_not_hole;
2931       __ Branch(&is_not_hole, ne, result, Operand(at));
2932       __ LoadRoot(result, Heap::kUndefinedValueRootIndex);
2933       __ bind(&is_not_hole);
2934     }
2935   }
2936 }
2937
2938
2939 void LCodeGen::DoStoreContextSlot(LStoreContextSlot* instr) {
2940   Register context = ToRegister(instr->context());
2941   Register value = ToRegister(instr->value());
2942   Register scratch = scratch0();
2943   MemOperand target = ContextOperand(context, instr->slot_index());
2944
2945   Label skip_assignment;
2946
2947   if (instr->hydrogen()->RequiresHoleCheck()) {
2948     __ lw(scratch, target);
2949     __ LoadRoot(at, Heap::kTheHoleValueRootIndex);
2950
2951     if (instr->hydrogen()->DeoptimizesOnHole()) {
2952       DeoptimizeIf(eq, instr->environment(), scratch, Operand(at));
2953     } else {
2954       __ Branch(&skip_assignment, ne, scratch, Operand(at));
2955     }
2956   }
2957
2958   __ sw(value, target);
2959   if (instr->hydrogen()->NeedsWriteBarrier()) {
2960     SmiCheck check_needed =
2961         instr->hydrogen()->value()->type().IsHeapObject()
2962             ? OMIT_SMI_CHECK : INLINE_SMI_CHECK;
2963     __ RecordWriteContextSlot(context,
2964                               target.offset(),
2965                               value,
2966                               scratch0(),
2967                               GetRAState(),
2968                               kSaveFPRegs,
2969                               EMIT_REMEMBERED_SET,
2970                               check_needed);
2971   }
2972
2973   __ bind(&skip_assignment);
2974 }
2975
2976
2977 void LCodeGen::DoLoadNamedField(LLoadNamedField* instr) {
2978   HObjectAccess access = instr->hydrogen()->access();
2979   int offset = access.offset();
2980   Register object = ToRegister(instr->object());
2981
2982   if (access.IsExternalMemory()) {
2983     Register result = ToRegister(instr->result());
2984     MemOperand operand = MemOperand(object, offset);
2985     __ Load(result, operand, access.representation());
2986     return;
2987   }
2988
2989   if (instr->hydrogen()->representation().IsDouble()) {
2990     DoubleRegister result = ToDoubleRegister(instr->result());
2991     __ ldc1(result, FieldMemOperand(object, offset));
2992     return;
2993   }
2994
2995   Register result = ToRegister(instr->result());
2996   if (!access.IsInobject()) {
2997     __ lw(result, FieldMemOperand(object, JSObject::kPropertiesOffset));
2998     object = result;
2999   }
3000   MemOperand operand = FieldMemOperand(object, offset);
3001   __ Load(result, operand, access.representation());
3002 }
3003
3004
3005 void LCodeGen::DoLoadNamedGeneric(LLoadNamedGeneric* instr) {
3006   ASSERT(ToRegister(instr->context()).is(cp));
3007   ASSERT(ToRegister(instr->object()).is(a0));
3008   ASSERT(ToRegister(instr->result()).is(v0));
3009
3010   // Name is always in a2.
3011   __ li(a2, Operand(instr->name()));
3012   Handle<Code> ic = LoadIC::initialize_stub(isolate(), NOT_CONTEXTUAL);
3013   CallCode(ic, RelocInfo::CODE_TARGET, instr);
3014 }
3015
3016
3017 void LCodeGen::DoLoadFunctionPrototype(LLoadFunctionPrototype* instr) {
3018   Register scratch = scratch0();
3019   Register function = ToRegister(instr->function());
3020   Register result = ToRegister(instr->result());
3021
3022   // Check that the function really is a function. Load map into the
3023   // result register.
3024   __ GetObjectType(function, result, scratch);
3025   DeoptimizeIf(ne, instr->environment(), scratch, Operand(JS_FUNCTION_TYPE));
3026
3027   // Make sure that the function has an instance prototype.
3028   Label non_instance;
3029   __ lbu(scratch, FieldMemOperand(result, Map::kBitFieldOffset));
3030   __ And(scratch, scratch, Operand(1 << Map::kHasNonInstancePrototype));
3031   __ Branch(&non_instance, ne, scratch, Operand(zero_reg));
3032
3033   // Get the prototype or initial map from the function.
3034   __ lw(result,
3035          FieldMemOperand(function, JSFunction::kPrototypeOrInitialMapOffset));
3036
3037   // Check that the function has a prototype or an initial map.
3038   __ LoadRoot(at, Heap::kTheHoleValueRootIndex);
3039   DeoptimizeIf(eq, instr->environment(), result, Operand(at));
3040
3041   // If the function does not have an initial map, we're done.
3042   Label done;
3043   __ GetObjectType(result, scratch, scratch);
3044   __ Branch(&done, ne, scratch, Operand(MAP_TYPE));
3045
3046   // Get the prototype from the initial map.
3047   __ lw(result, FieldMemOperand(result, Map::kPrototypeOffset));
3048   __ Branch(&done);
3049
3050   // Non-instance prototype: Fetch prototype from constructor field
3051   // in initial map.
3052   __ bind(&non_instance);
3053   __ lw(result, FieldMemOperand(result, Map::kConstructorOffset));
3054
3055   // All done.
3056   __ bind(&done);
3057 }
3058
3059
3060 void LCodeGen::DoLoadRoot(LLoadRoot* instr) {
3061   Register result = ToRegister(instr->result());
3062   __ LoadRoot(result, instr->index());
3063 }
3064
3065
3066 void LCodeGen::DoAccessArgumentsAt(LAccessArgumentsAt* instr) {
3067   Register arguments = ToRegister(instr->arguments());
3068   Register result = ToRegister(instr->result());
3069   // There are two words between the frame pointer and the last argument.
3070   // Subtracting from length accounts for one of them add one more.
3071   if (instr->length()->IsConstantOperand()) {
3072     int const_length = ToInteger32(LConstantOperand::cast(instr->length()));
3073     if (instr->index()->IsConstantOperand()) {
3074       int const_index = ToInteger32(LConstantOperand::cast(instr->index()));
3075       int index = (const_length - const_index) + 1;
3076       __ lw(result, MemOperand(arguments, index * kPointerSize));
3077     } else {
3078       Register index = ToRegister(instr->index());
3079       __ li(at, Operand(const_length + 1));
3080       __ Subu(result, at, index);
3081       __ sll(at, result, kPointerSizeLog2);
3082       __ Addu(at, arguments, at);
3083       __ lw(result, MemOperand(at));
3084     }
3085   } else if (instr->index()->IsConstantOperand()) {
3086     Register length = ToRegister(instr->length());
3087     int const_index = ToInteger32(LConstantOperand::cast(instr->index()));
3088     int loc = const_index - 1;
3089     if (loc != 0) {
3090       __ Subu(result, length, Operand(loc));
3091       __ sll(at, result, kPointerSizeLog2);
3092       __ Addu(at, arguments, at);
3093       __ lw(result, MemOperand(at));
3094     } else {
3095       __ sll(at, length, kPointerSizeLog2);
3096       __ Addu(at, arguments, at);
3097       __ lw(result, MemOperand(at));
3098     }
3099   } else {
3100     Register length = ToRegister(instr->length());
3101     Register index = ToRegister(instr->index());
3102     __ Subu(result, length, index);
3103     __ Addu(result, result, 1);
3104     __ sll(at, result, kPointerSizeLog2);
3105     __ Addu(at, arguments, at);
3106     __ lw(result, MemOperand(at));
3107   }
3108 }
3109
3110
3111 void LCodeGen::DoLoadKeyedExternalArray(LLoadKeyed* instr) {
3112   Register external_pointer = ToRegister(instr->elements());
3113   Register key = no_reg;
3114   ElementsKind elements_kind = instr->elements_kind();
3115   bool key_is_constant = instr->key()->IsConstantOperand();
3116   int constant_key = 0;
3117   if (key_is_constant) {
3118     constant_key = ToInteger32(LConstantOperand::cast(instr->key()));
3119     if (constant_key & 0xF0000000) {
3120       Abort(kArrayIndexConstantValueTooBig);
3121     }
3122   } else {
3123     key = ToRegister(instr->key());
3124   }
3125   int element_size_shift = ElementsKindToShiftSize(elements_kind);
3126   int shift_size = (instr->hydrogen()->key()->representation().IsSmi())
3127       ? (element_size_shift - kSmiTagSize) : element_size_shift;
3128   int base_offset = instr->base_offset();
3129
3130   if (elements_kind == EXTERNAL_FLOAT32_ELEMENTS ||
3131       elements_kind == FLOAT32_ELEMENTS ||
3132       elements_kind == EXTERNAL_FLOAT64_ELEMENTS ||
3133       elements_kind == FLOAT64_ELEMENTS) {
3134     int base_offset = instr->base_offset();
3135     FPURegister result = ToDoubleRegister(instr->result());
3136     if (key_is_constant) {
3137       __ Addu(scratch0(), external_pointer, constant_key << element_size_shift);
3138     } else {
3139       __ sll(scratch0(), key, shift_size);
3140       __ Addu(scratch0(), scratch0(), external_pointer);
3141     }
3142     if (elements_kind == EXTERNAL_FLOAT32_ELEMENTS ||
3143         elements_kind == FLOAT32_ELEMENTS) {
3144       __ lwc1(result, MemOperand(scratch0(), base_offset));
3145       __ cvt_d_s(result, result);
3146     } else  {  // i.e. elements_kind == EXTERNAL_DOUBLE_ELEMENTS
3147       __ ldc1(result, MemOperand(scratch0(), base_offset));
3148     }
3149   } else {
3150     Register result = ToRegister(instr->result());
3151     MemOperand mem_operand = PrepareKeyedOperand(
3152         key, external_pointer, key_is_constant, constant_key,
3153         element_size_shift, shift_size, base_offset);
3154     switch (elements_kind) {
3155       case EXTERNAL_INT8_ELEMENTS:
3156       case INT8_ELEMENTS:
3157         __ lb(result, mem_operand);
3158         break;
3159       case EXTERNAL_UINT8_CLAMPED_ELEMENTS:
3160       case EXTERNAL_UINT8_ELEMENTS:
3161       case UINT8_ELEMENTS:
3162       case UINT8_CLAMPED_ELEMENTS:
3163         __ lbu(result, mem_operand);
3164         break;
3165       case EXTERNAL_INT16_ELEMENTS:
3166       case INT16_ELEMENTS:
3167         __ lh(result, mem_operand);
3168         break;
3169       case EXTERNAL_UINT16_ELEMENTS:
3170       case UINT16_ELEMENTS:
3171         __ lhu(result, mem_operand);
3172         break;
3173       case EXTERNAL_INT32_ELEMENTS:
3174       case INT32_ELEMENTS:
3175         __ lw(result, mem_operand);
3176         break;
3177       case EXTERNAL_UINT32_ELEMENTS:
3178       case UINT32_ELEMENTS:
3179         __ lw(result, mem_operand);
3180         if (!instr->hydrogen()->CheckFlag(HInstruction::kUint32)) {
3181           DeoptimizeIf(Ugreater_equal, instr->environment(),
3182               result, Operand(0x80000000));
3183         }
3184         break;
3185       case FLOAT32_ELEMENTS:
3186       case FLOAT64_ELEMENTS:
3187       case EXTERNAL_FLOAT32_ELEMENTS:
3188       case EXTERNAL_FLOAT64_ELEMENTS:
3189       case FAST_DOUBLE_ELEMENTS:
3190       case FAST_ELEMENTS:
3191       case FAST_SMI_ELEMENTS:
3192       case FAST_HOLEY_DOUBLE_ELEMENTS:
3193       case FAST_HOLEY_ELEMENTS:
3194       case FAST_HOLEY_SMI_ELEMENTS:
3195       case DICTIONARY_ELEMENTS:
3196       case SLOPPY_ARGUMENTS_ELEMENTS:
3197         UNREACHABLE();
3198         break;
3199     }
3200   }
3201 }
3202
3203
3204 void LCodeGen::DoLoadKeyedFixedDoubleArray(LLoadKeyed* instr) {
3205   Register elements = ToRegister(instr->elements());
3206   bool key_is_constant = instr->key()->IsConstantOperand();
3207   Register key = no_reg;
3208   DoubleRegister result = ToDoubleRegister(instr->result());
3209   Register scratch = scratch0();
3210
3211   int element_size_shift = ElementsKindToShiftSize(FAST_DOUBLE_ELEMENTS);
3212
3213   int base_offset = instr->base_offset();
3214   if (key_is_constant) {
3215     int constant_key = ToInteger32(LConstantOperand::cast(instr->key()));
3216     if (constant_key & 0xF0000000) {
3217       Abort(kArrayIndexConstantValueTooBig);
3218     }
3219     base_offset += constant_key * kDoubleSize;
3220   }
3221   __ Addu(scratch, elements, Operand(base_offset));
3222
3223   if (!key_is_constant) {
3224     key = ToRegister(instr->key());
3225     int shift_size = (instr->hydrogen()->key()->representation().IsSmi())
3226         ? (element_size_shift - kSmiTagSize) : element_size_shift;
3227     __ sll(at, key, shift_size);
3228     __ Addu(scratch, scratch, at);
3229   }
3230
3231   __ ldc1(result, MemOperand(scratch));
3232
3233   if (instr->hydrogen()->RequiresHoleCheck()) {
3234     __ lw(scratch, MemOperand(scratch, kHoleNanUpper32Offset));
3235     DeoptimizeIf(eq, instr->environment(), scratch, Operand(kHoleNanUpper32));
3236   }
3237 }
3238
3239
3240 void LCodeGen::DoLoadKeyedFixedArray(LLoadKeyed* instr) {
3241   Register elements = ToRegister(instr->elements());
3242   Register result = ToRegister(instr->result());
3243   Register scratch = scratch0();
3244   Register store_base = scratch;
3245   int offset = instr->base_offset();
3246
3247   if (instr->key()->IsConstantOperand()) {
3248     LConstantOperand* const_operand = LConstantOperand::cast(instr->key());
3249     offset += ToInteger32(const_operand) * kPointerSize;
3250     store_base = elements;
3251   } else {
3252     Register key = ToRegister(instr->key());
3253     // Even though the HLoadKeyed instruction forces the input
3254     // representation for the key to be an integer, the input gets replaced
3255     // during bound check elimination with the index argument to the bounds
3256     // check, which can be tagged, so that case must be handled here, too.
3257     if (instr->hydrogen()->key()->representation().IsSmi()) {
3258       __ sll(scratch, key, kPointerSizeLog2 - kSmiTagSize);
3259       __ addu(scratch, elements, scratch);
3260     } else {
3261       __ sll(scratch, key, kPointerSizeLog2);
3262       __ addu(scratch, elements, scratch);
3263     }
3264   }
3265   __ lw(result, MemOperand(store_base, offset));
3266
3267   // Check for the hole value.
3268   if (instr->hydrogen()->RequiresHoleCheck()) {
3269     if (IsFastSmiElementsKind(instr->hydrogen()->elements_kind())) {
3270       __ SmiTst(result, scratch);
3271       DeoptimizeIf(ne, instr->environment(), scratch, Operand(zero_reg));
3272     } else {
3273       __ LoadRoot(scratch, Heap::kTheHoleValueRootIndex);
3274       DeoptimizeIf(eq, instr->environment(), result, Operand(scratch));
3275     }
3276   }
3277 }
3278
3279
3280 void LCodeGen::DoLoadKeyed(LLoadKeyed* instr) {
3281   if (instr->is_typed_elements()) {
3282     DoLoadKeyedExternalArray(instr);
3283   } else if (instr->hydrogen()->representation().IsDouble()) {
3284     DoLoadKeyedFixedDoubleArray(instr);
3285   } else {
3286     DoLoadKeyedFixedArray(instr);
3287   }
3288 }
3289
3290
3291 MemOperand LCodeGen::PrepareKeyedOperand(Register key,
3292                                          Register base,
3293                                          bool key_is_constant,
3294                                          int constant_key,
3295                                          int element_size,
3296                                          int shift_size,
3297                                          int base_offset) {
3298   if (key_is_constant) {
3299     return MemOperand(base, (constant_key << element_size) + base_offset);
3300   }
3301
3302   if (base_offset == 0) {
3303     if (shift_size >= 0) {
3304       __ sll(scratch0(), key, shift_size);
3305       __ Addu(scratch0(), base, scratch0());
3306       return MemOperand(scratch0());
3307     } else {
3308       ASSERT_EQ(-1, shift_size);
3309       __ srl(scratch0(), key, 1);
3310       __ Addu(scratch0(), base, scratch0());
3311       return MemOperand(scratch0());
3312     }
3313   }
3314
3315   if (shift_size >= 0) {
3316     __ sll(scratch0(), key, shift_size);
3317     __ Addu(scratch0(), base, scratch0());
3318     return MemOperand(scratch0(), base_offset);
3319   } else {
3320     ASSERT_EQ(-1, shift_size);
3321     __ sra(scratch0(), key, 1);
3322     __ Addu(scratch0(), base, scratch0());
3323     return MemOperand(scratch0(), base_offset);
3324   }
3325 }
3326
3327
3328 void LCodeGen::DoLoadKeyedGeneric(LLoadKeyedGeneric* instr) {
3329   ASSERT(ToRegister(instr->context()).is(cp));
3330   ASSERT(ToRegister(instr->object()).is(a1));
3331   ASSERT(ToRegister(instr->key()).is(a0));
3332
3333   Handle<Code> ic = isolate()->builtins()->KeyedLoadIC_Initialize();
3334   CallCode(ic, RelocInfo::CODE_TARGET, instr);
3335 }
3336
3337
3338 void LCodeGen::DoArgumentsElements(LArgumentsElements* instr) {
3339   Register scratch = scratch0();
3340   Register temp = scratch1();
3341   Register result = ToRegister(instr->result());
3342
3343   if (instr->hydrogen()->from_inlined()) {
3344     __ Subu(result, sp, 2 * kPointerSize);
3345   } else {
3346     // Check if the calling frame is an arguments adaptor frame.
3347     Label done, adapted;
3348     __ lw(scratch, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
3349     __ lw(result, MemOperand(scratch, StandardFrameConstants::kContextOffset));
3350     __ Xor(temp, result, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
3351
3352     // Result is the frame pointer for the frame if not adapted and for the real
3353     // frame below the adaptor frame if adapted.
3354     __ Movn(result, fp, temp);  // Move only if temp is not equal to zero (ne).
3355     __ Movz(result, scratch, temp);  // Move only if temp is equal to zero (eq).
3356   }
3357 }
3358
3359
3360 void LCodeGen::DoArgumentsLength(LArgumentsLength* instr) {
3361   Register elem = ToRegister(instr->elements());
3362   Register result = ToRegister(instr->result());
3363
3364   Label done;
3365
3366   // If no arguments adaptor frame the number of arguments is fixed.
3367   __ Addu(result, zero_reg, Operand(scope()->num_parameters()));
3368   __ Branch(&done, eq, fp, Operand(elem));
3369
3370   // Arguments adaptor frame present. Get argument length from there.
3371   __ lw(result, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
3372   __ lw(result,
3373         MemOperand(result, ArgumentsAdaptorFrameConstants::kLengthOffset));
3374   __ SmiUntag(result);
3375
3376   // Argument length is in result register.
3377   __ bind(&done);
3378 }
3379
3380
3381 void LCodeGen::DoWrapReceiver(LWrapReceiver* instr) {
3382   Register receiver = ToRegister(instr->receiver());
3383   Register function = ToRegister(instr->function());
3384   Register result = ToRegister(instr->result());
3385   Register scratch = scratch0();
3386
3387   // If the receiver is null or undefined, we have to pass the global
3388   // object as a receiver to normal functions. Values have to be
3389   // passed unchanged to builtins and strict-mode functions.
3390   Label global_object, result_in_receiver;
3391
3392   if (!instr->hydrogen()->known_function()) {
3393     // Do not transform the receiver to object for strict mode
3394     // functions.
3395     __ lw(scratch,
3396            FieldMemOperand(function, JSFunction::kSharedFunctionInfoOffset));
3397     __ lw(scratch,
3398            FieldMemOperand(scratch, SharedFunctionInfo::kCompilerHintsOffset));
3399
3400     // Do not transform the receiver to object for builtins.
3401     int32_t strict_mode_function_mask =
3402         1 <<  (SharedFunctionInfo::kStrictModeFunction + kSmiTagSize);
3403     int32_t native_mask = 1 << (SharedFunctionInfo::kNative + kSmiTagSize);
3404     __ And(scratch, scratch, Operand(strict_mode_function_mask | native_mask));
3405     __ Branch(&result_in_receiver, ne, scratch, Operand(zero_reg));
3406   }
3407
3408   // Normal function. Replace undefined or null with global receiver.
3409   __ LoadRoot(scratch, Heap::kNullValueRootIndex);
3410   __ Branch(&global_object, eq, receiver, Operand(scratch));
3411   __ LoadRoot(scratch, Heap::kUndefinedValueRootIndex);
3412   __ Branch(&global_object, eq, receiver, Operand(scratch));
3413
3414   // Deoptimize if the receiver is not a JS object.
3415   __ SmiTst(receiver, scratch);
3416   DeoptimizeIf(eq, instr->environment(), scratch, Operand(zero_reg));
3417
3418   __ GetObjectType(receiver, scratch, scratch);
3419   DeoptimizeIf(lt, instr->environment(),
3420                scratch, Operand(FIRST_SPEC_OBJECT_TYPE));
3421
3422   __ Branch(&result_in_receiver);
3423   __ bind(&global_object);
3424   __ lw(result, FieldMemOperand(function, JSFunction::kContextOffset));
3425   __ lw(result,
3426         ContextOperand(result, Context::GLOBAL_OBJECT_INDEX));
3427   __ lw(result,
3428         FieldMemOperand(result, GlobalObject::kGlobalReceiverOffset));
3429
3430   if (result.is(receiver)) {
3431     __ bind(&result_in_receiver);
3432   } else {
3433     Label result_ok;
3434     __ Branch(&result_ok);
3435     __ bind(&result_in_receiver);
3436     __ mov(result, receiver);
3437     __ bind(&result_ok);
3438   }
3439 }
3440
3441
3442 void LCodeGen::DoApplyArguments(LApplyArguments* instr) {
3443   Register receiver = ToRegister(instr->receiver());
3444   Register function = ToRegister(instr->function());
3445   Register length = ToRegister(instr->length());
3446   Register elements = ToRegister(instr->elements());
3447   Register scratch = scratch0();
3448   ASSERT(receiver.is(a0));  // Used for parameter count.
3449   ASSERT(function.is(a1));  // Required by InvokeFunction.
3450   ASSERT(ToRegister(instr->result()).is(v0));
3451
3452   // Copy the arguments to this function possibly from the
3453   // adaptor frame below it.
3454   const uint32_t kArgumentsLimit = 1 * KB;
3455   DeoptimizeIf(hi, instr->environment(), length, Operand(kArgumentsLimit));
3456
3457   // Push the receiver and use the register to keep the original
3458   // number of arguments.
3459   __ push(receiver);
3460   __ Move(receiver, length);
3461   // The arguments are at a one pointer size offset from elements.
3462   __ Addu(elements, elements, Operand(1 * kPointerSize));
3463
3464   // Loop through the arguments pushing them onto the execution
3465   // stack.
3466   Label invoke, loop;
3467   // length is a small non-negative integer, due to the test above.
3468   __ Branch(USE_DELAY_SLOT, &invoke, eq, length, Operand(zero_reg));
3469   __ sll(scratch, length, 2);
3470   __ bind(&loop);
3471   __ Addu(scratch, elements, scratch);
3472   __ lw(scratch, MemOperand(scratch));
3473   __ push(scratch);
3474   __ Subu(length, length, Operand(1));
3475   __ Branch(USE_DELAY_SLOT, &loop, ne, length, Operand(zero_reg));
3476   __ sll(scratch, length, 2);
3477
3478   __ bind(&invoke);
3479   ASSERT(instr->HasPointerMap());
3480   LPointerMap* pointers = instr->pointer_map();
3481   SafepointGenerator safepoint_generator(
3482       this, pointers, Safepoint::kLazyDeopt);
3483   // The number of arguments is stored in receiver which is a0, as expected
3484   // by InvokeFunction.
3485   ParameterCount actual(receiver);
3486   __ InvokeFunction(function, actual, CALL_FUNCTION, safepoint_generator);
3487 }
3488
3489
3490 void LCodeGen::DoPushArgument(LPushArgument* instr) {
3491   LOperand* argument = instr->value();
3492   if (argument->IsDoubleRegister() || argument->IsDoubleStackSlot()) {
3493     Abort(kDoPushArgumentNotImplementedForDoubleType);
3494   } else {
3495     Register argument_reg = EmitLoadRegister(argument, at);
3496     __ push(argument_reg);
3497   }
3498 }
3499
3500
3501 void LCodeGen::DoDrop(LDrop* instr) {
3502   __ Drop(instr->count());
3503 }
3504
3505
3506 void LCodeGen::DoThisFunction(LThisFunction* instr) {
3507   Register result = ToRegister(instr->result());
3508   __ lw(result, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
3509 }
3510
3511
3512 void LCodeGen::DoContext(LContext* instr) {
3513   // If there is a non-return use, the context must be moved to a register.
3514   Register result = ToRegister(instr->result());
3515   if (info()->IsOptimizing()) {
3516     __ lw(result, MemOperand(fp, StandardFrameConstants::kContextOffset));
3517   } else {
3518     // If there is no frame, the context must be in cp.
3519     ASSERT(result.is(cp));
3520   }
3521 }
3522
3523
3524 void LCodeGen::DoDeclareGlobals(LDeclareGlobals* instr) {
3525   ASSERT(ToRegister(instr->context()).is(cp));
3526   __ li(scratch0(), instr->hydrogen()->pairs());
3527   __ li(scratch1(), Operand(Smi::FromInt(instr->hydrogen()->flags())));
3528   // The context is the first argument.
3529   __ Push(cp, scratch0(), scratch1());
3530   CallRuntime(Runtime::kHiddenDeclareGlobals, 3, instr);
3531 }
3532
3533
3534 void LCodeGen::CallKnownFunction(Handle<JSFunction> function,
3535                                  int formal_parameter_count,
3536                                  int arity,
3537                                  LInstruction* instr,
3538                                  A1State a1_state) {
3539   bool dont_adapt_arguments =
3540       formal_parameter_count == SharedFunctionInfo::kDontAdaptArgumentsSentinel;
3541   bool can_invoke_directly =
3542       dont_adapt_arguments || formal_parameter_count == arity;
3543
3544   LPointerMap* pointers = instr->pointer_map();
3545
3546   if (can_invoke_directly) {
3547     if (a1_state == A1_UNINITIALIZED) {
3548       __ li(a1, function);
3549     }
3550
3551     // Change context.
3552     __ lw(cp, FieldMemOperand(a1, JSFunction::kContextOffset));
3553
3554     // Set r0 to arguments count if adaption is not needed. Assumes that r0
3555     // is available to write to at this point.
3556     if (dont_adapt_arguments) {
3557       __ li(a0, Operand(arity));
3558     }
3559
3560     // Invoke function.
3561     __ lw(at, FieldMemOperand(a1, JSFunction::kCodeEntryOffset));
3562     __ Call(at);
3563
3564     // Set up deoptimization.
3565     RecordSafepointWithLazyDeopt(instr, RECORD_SIMPLE_SAFEPOINT);
3566   } else {
3567     SafepointGenerator generator(this, pointers, Safepoint::kLazyDeopt);
3568     ParameterCount count(arity);
3569     ParameterCount expected(formal_parameter_count);
3570     __ InvokeFunction(function, expected, count, CALL_FUNCTION, generator);
3571   }
3572 }
3573
3574
3575 void LCodeGen::DoDeferredMathAbsTaggedHeapNumber(LMathAbs* instr) {
3576   ASSERT(instr->context() != NULL);
3577   ASSERT(ToRegister(instr->context()).is(cp));
3578   Register input = ToRegister(instr->value());
3579   Register result = ToRegister(instr->result());
3580   Register scratch = scratch0();
3581
3582   // Deoptimize if not a heap number.
3583   __ lw(scratch, FieldMemOperand(input, HeapObject::kMapOffset));
3584   __ LoadRoot(at, Heap::kHeapNumberMapRootIndex);
3585   DeoptimizeIf(ne, instr->environment(), scratch, Operand(at));
3586
3587   Label done;
3588   Register exponent = scratch0();
3589   scratch = no_reg;
3590   __ lw(exponent, FieldMemOperand(input, HeapNumber::kExponentOffset));
3591   // Check the sign of the argument. If the argument is positive, just
3592   // return it.
3593   __ Move(result, input);
3594   __ And(at, exponent, Operand(HeapNumber::kSignMask));
3595   __ Branch(&done, eq, at, Operand(zero_reg));
3596
3597   // Input is negative. Reverse its sign.
3598   // Preserve the value of all registers.
3599   {
3600     PushSafepointRegistersScope scope(this, Safepoint::kWithRegisters);
3601
3602     // Registers were saved at the safepoint, so we can use
3603     // many scratch registers.
3604     Register tmp1 = input.is(a1) ? a0 : a1;
3605     Register tmp2 = input.is(a2) ? a0 : a2;
3606     Register tmp3 = input.is(a3) ? a0 : a3;
3607     Register tmp4 = input.is(t0) ? a0 : t0;
3608
3609     // exponent: floating point exponent value.
3610
3611     Label allocated, slow;
3612     __ LoadRoot(tmp4, Heap::kHeapNumberMapRootIndex);
3613     __ AllocateHeapNumber(tmp1, tmp2, tmp3, tmp4, &slow);
3614     __ Branch(&allocated);
3615
3616     // Slow case: Call the runtime system to do the number allocation.
3617     __ bind(&slow);
3618
3619     CallRuntimeFromDeferred(Runtime::kHiddenAllocateHeapNumber, 0, instr,
3620                             instr->context());
3621     // Set the pointer to the new heap number in tmp.
3622     if (!tmp1.is(v0))
3623       __ mov(tmp1, v0);
3624     // Restore input_reg after call to runtime.
3625     __ LoadFromSafepointRegisterSlot(input, input);
3626     __ lw(exponent, FieldMemOperand(input, HeapNumber::kExponentOffset));
3627
3628     __ bind(&allocated);
3629     // exponent: floating point exponent value.
3630     // tmp1: allocated heap number.
3631     __ And(exponent, exponent, Operand(~HeapNumber::kSignMask));
3632     __ sw(exponent, FieldMemOperand(tmp1, HeapNumber::kExponentOffset));
3633     __ lw(tmp2, FieldMemOperand(input, HeapNumber::kMantissaOffset));
3634     __ sw(tmp2, FieldMemOperand(tmp1, HeapNumber::kMantissaOffset));
3635
3636     __ StoreToSafepointRegisterSlot(tmp1, result);
3637   }
3638
3639   __ bind(&done);
3640 }
3641
3642
3643 void LCodeGen::EmitIntegerMathAbs(LMathAbs* instr) {
3644   Register input = ToRegister(instr->value());
3645   Register result = ToRegister(instr->result());
3646   Assembler::BlockTrampolinePoolScope block_trampoline_pool(masm_);
3647   Label done;
3648   __ Branch(USE_DELAY_SLOT, &done, ge, input, Operand(zero_reg));
3649   __ mov(result, input);
3650   __ subu(result, zero_reg, input);
3651   // Overflow if result is still negative, i.e. 0x80000000.
3652   DeoptimizeIf(lt, instr->environment(), result, Operand(zero_reg));
3653   __ bind(&done);
3654 }
3655
3656
3657 void LCodeGen::DoMathAbs(LMathAbs* instr) {
3658   // Class for deferred case.
3659   class DeferredMathAbsTaggedHeapNumber V8_FINAL : public LDeferredCode {
3660    public:
3661     DeferredMathAbsTaggedHeapNumber(LCodeGen* codegen, LMathAbs* instr)
3662         : LDeferredCode(codegen), instr_(instr) { }
3663     virtual void Generate() V8_OVERRIDE {
3664       codegen()->DoDeferredMathAbsTaggedHeapNumber(instr_);
3665     }
3666     virtual LInstruction* instr() V8_OVERRIDE { return instr_; }
3667    private:
3668     LMathAbs* instr_;
3669   };
3670
3671   Representation r = instr->hydrogen()->value()->representation();
3672   if (r.IsDouble()) {
3673     FPURegister input = ToDoubleRegister(instr->value());
3674     FPURegister result = ToDoubleRegister(instr->result());
3675     __ abs_d(result, input);
3676   } else if (r.IsSmiOrInteger32()) {
3677     EmitIntegerMathAbs(instr);
3678   } else {
3679     // Representation is tagged.
3680     DeferredMathAbsTaggedHeapNumber* deferred =
3681         new(zone()) DeferredMathAbsTaggedHeapNumber(this, instr);
3682     Register input = ToRegister(instr->value());
3683     // Smi check.
3684     __ JumpIfNotSmi(input, deferred->entry());
3685     // If smi, handle it directly.
3686     EmitIntegerMathAbs(instr);
3687     __ bind(deferred->exit());
3688   }
3689 }
3690
3691
3692 void LCodeGen::DoMathFloor(LMathFloor* instr) {
3693   DoubleRegister input = ToDoubleRegister(instr->value());
3694   Register result = ToRegister(instr->result());
3695   Register scratch1 = scratch0();
3696   Register except_flag = ToRegister(instr->temp());
3697
3698   __ EmitFPUTruncate(kRoundToMinusInf,
3699                      result,
3700                      input,
3701                      scratch1,
3702                      double_scratch0(),
3703                      except_flag);
3704
3705   // Deopt if the operation did not succeed.
3706   DeoptimizeIf(ne, instr->environment(), except_flag, Operand(zero_reg));
3707
3708   if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
3709     // Test for -0.
3710     Label done;
3711     __ Branch(&done, ne, result, Operand(zero_reg));
3712     __ mfc1(scratch1, input.high());
3713     __ And(scratch1, scratch1, Operand(HeapNumber::kSignMask));
3714     DeoptimizeIf(ne, instr->environment(), scratch1, Operand(zero_reg));
3715     __ bind(&done);
3716   }
3717 }
3718
3719
3720 void LCodeGen::DoMathRound(LMathRound* instr) {
3721   DoubleRegister input = ToDoubleRegister(instr->value());
3722   Register result = ToRegister(instr->result());
3723   DoubleRegister double_scratch1 = ToDoubleRegister(instr->temp());
3724   Register scratch = scratch0();
3725   Label done, check_sign_on_zero;
3726
3727   // Extract exponent bits.
3728   __ mfc1(result, input.high());
3729   __ Ext(scratch,
3730          result,
3731          HeapNumber::kExponentShift,
3732          HeapNumber::kExponentBits);
3733
3734   // If the number is in ]-0.5, +0.5[, the result is +/- 0.
3735   Label skip1;
3736   __ Branch(&skip1, gt, scratch, Operand(HeapNumber::kExponentBias - 2));
3737   __ mov(result, zero_reg);
3738   if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
3739     __ Branch(&check_sign_on_zero);
3740   } else {
3741     __ Branch(&done);
3742   }
3743   __ bind(&skip1);
3744
3745   // The following conversion will not work with numbers
3746   // outside of ]-2^32, 2^32[.
3747   DeoptimizeIf(ge, instr->environment(), scratch,
3748                Operand(HeapNumber::kExponentBias + 32));
3749
3750   // Save the original sign for later comparison.
3751   __ And(scratch, result, Operand(HeapNumber::kSignMask));
3752
3753   __ Move(double_scratch0(), 0.5);
3754   __ add_d(double_scratch0(), input, double_scratch0());
3755
3756   // Check sign of the result: if the sign changed, the input
3757   // value was in ]0.5, 0[ and the result should be -0.
3758   __ mfc1(result, double_scratch0().high());
3759   __ Xor(result, result, Operand(scratch));
3760   if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
3761     // ARM uses 'mi' here, which is 'lt'
3762     DeoptimizeIf(lt, instr->environment(), result,
3763                  Operand(zero_reg));
3764   } else {
3765     Label skip2;
3766     // ARM uses 'mi' here, which is 'lt'
3767     // Negating it results in 'ge'
3768     __ Branch(&skip2, ge, result, Operand(zero_reg));
3769     __ mov(result, zero_reg);
3770     __ Branch(&done);
3771     __ bind(&skip2);
3772   }
3773
3774   Register except_flag = scratch;
3775   __ EmitFPUTruncate(kRoundToMinusInf,
3776                      result,
3777                      double_scratch0(),
3778                      at,
3779                      double_scratch1,
3780                      except_flag);
3781
3782   DeoptimizeIf(ne, instr->environment(), except_flag, Operand(zero_reg));
3783
3784   if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
3785     // Test for -0.
3786     __ Branch(&done, ne, result, Operand(zero_reg));
3787     __ bind(&check_sign_on_zero);
3788     __ mfc1(scratch, input.high());
3789     __ And(scratch, scratch, Operand(HeapNumber::kSignMask));
3790     DeoptimizeIf(ne, instr->environment(), scratch, Operand(zero_reg));
3791   }
3792   __ bind(&done);
3793 }
3794
3795
3796 void LCodeGen::DoMathSqrt(LMathSqrt* instr) {
3797   DoubleRegister input = ToDoubleRegister(instr->value());
3798   DoubleRegister result = ToDoubleRegister(instr->result());
3799   __ sqrt_d(result, input);
3800 }
3801
3802
3803 void LCodeGen::DoMathPowHalf(LMathPowHalf* instr) {
3804   DoubleRegister input = ToDoubleRegister(instr->value());
3805   DoubleRegister result = ToDoubleRegister(instr->result());
3806   DoubleRegister temp = ToDoubleRegister(instr->temp());
3807
3808   ASSERT(!input.is(result));
3809
3810   // Note that according to ECMA-262 15.8.2.13:
3811   // Math.pow(-Infinity, 0.5) == Infinity
3812   // Math.sqrt(-Infinity) == NaN
3813   Label done;
3814   __ Move(temp, -V8_INFINITY);
3815   __ BranchF(USE_DELAY_SLOT, &done, NULL, eq, temp, input);
3816   // Set up Infinity in the delay slot.
3817   // result is overwritten if the branch is not taken.
3818   __ neg_d(result, temp);
3819
3820   // Add +0 to convert -0 to +0.
3821   __ add_d(result, input, kDoubleRegZero);
3822   __ sqrt_d(result, result);
3823   __ bind(&done);
3824 }
3825
3826
3827 void LCodeGen::DoPower(LPower* instr) {
3828   Representation exponent_type = instr->hydrogen()->right()->representation();
3829   // Having marked this as a call, we can use any registers.
3830   // Just make sure that the input/output registers are the expected ones.
3831   ASSERT(!instr->right()->IsDoubleRegister() ||
3832          ToDoubleRegister(instr->right()).is(f4));
3833   ASSERT(!instr->right()->IsRegister() ||
3834          ToRegister(instr->right()).is(a2));
3835   ASSERT(ToDoubleRegister(instr->left()).is(f2));
3836   ASSERT(ToDoubleRegister(instr->result()).is(f0));
3837
3838   if (exponent_type.IsSmi()) {
3839     MathPowStub stub(isolate(), MathPowStub::TAGGED);
3840     __ CallStub(&stub);
3841   } else if (exponent_type.IsTagged()) {
3842     Label no_deopt;
3843     __ JumpIfSmi(a2, &no_deopt);
3844     __ lw(t3, FieldMemOperand(a2, HeapObject::kMapOffset));
3845     __ LoadRoot(at, Heap::kHeapNumberMapRootIndex);
3846     DeoptimizeIf(ne, instr->environment(), t3, Operand(at));
3847     __ bind(&no_deopt);
3848     MathPowStub stub(isolate(), MathPowStub::TAGGED);
3849     __ CallStub(&stub);
3850   } else if (exponent_type.IsInteger32()) {
3851     MathPowStub stub(isolate(), MathPowStub::INTEGER);
3852     __ CallStub(&stub);
3853   } else {
3854     ASSERT(exponent_type.IsDouble());
3855     MathPowStub stub(isolate(), MathPowStub::DOUBLE);
3856     __ CallStub(&stub);
3857   }
3858 }
3859
3860
3861 void LCodeGen::DoMathExp(LMathExp* instr) {
3862   DoubleRegister input = ToDoubleRegister(instr->value());
3863   DoubleRegister result = ToDoubleRegister(instr->result());
3864   DoubleRegister double_scratch1 = ToDoubleRegister(instr->double_temp());
3865   DoubleRegister double_scratch2 = double_scratch0();
3866   Register temp1 = ToRegister(instr->temp1());
3867   Register temp2 = ToRegister(instr->temp2());
3868
3869   MathExpGenerator::EmitMathExp(
3870       masm(), input, result, double_scratch1, double_scratch2,
3871       temp1, temp2, scratch0());
3872 }
3873
3874
3875 void LCodeGen::DoMathLog(LMathLog* instr) {
3876   __ PrepareCallCFunction(0, 1, scratch0());
3877   __ MovToFloatParameter(ToDoubleRegister(instr->value()));
3878   __ CallCFunction(ExternalReference::math_log_double_function(isolate()),
3879                    0, 1);
3880   __ MovFromFloatResult(ToDoubleRegister(instr->result()));
3881 }
3882
3883
3884 void LCodeGen::DoMathClz32(LMathClz32* instr) {
3885   Register input = ToRegister(instr->value());
3886   Register result = ToRegister(instr->result());
3887   __ Clz(result, input);
3888 }
3889
3890
3891 void LCodeGen::DoInvokeFunction(LInvokeFunction* instr) {
3892   ASSERT(ToRegister(instr->context()).is(cp));
3893   ASSERT(ToRegister(instr->function()).is(a1));
3894   ASSERT(instr->HasPointerMap());
3895
3896   Handle<JSFunction> known_function = instr->hydrogen()->known_function();
3897   if (known_function.is_null()) {
3898     LPointerMap* pointers = instr->pointer_map();
3899     SafepointGenerator generator(this, pointers, Safepoint::kLazyDeopt);
3900     ParameterCount count(instr->arity());
3901     __ InvokeFunction(a1, count, CALL_FUNCTION, generator);
3902   } else {
3903     CallKnownFunction(known_function,
3904                       instr->hydrogen()->formal_parameter_count(),
3905                       instr->arity(),
3906                       instr,
3907                       A1_CONTAINS_TARGET);
3908   }
3909 }
3910
3911
3912 void LCodeGen::DoCallWithDescriptor(LCallWithDescriptor* instr) {
3913   ASSERT(ToRegister(instr->result()).is(v0));
3914
3915   LPointerMap* pointers = instr->pointer_map();
3916   SafepointGenerator generator(this, pointers, Safepoint::kLazyDeopt);
3917
3918   if (instr->target()->IsConstantOperand()) {
3919     LConstantOperand* target = LConstantOperand::cast(instr->target());
3920     Handle<Code> code = Handle<Code>::cast(ToHandle(target));
3921     generator.BeforeCall(__ CallSize(code, RelocInfo::CODE_TARGET));
3922     __ Call(code, RelocInfo::CODE_TARGET);
3923   } else {
3924     ASSERT(instr->target()->IsRegister());
3925     Register target = ToRegister(instr->target());
3926     generator.BeforeCall(__ CallSize(target));
3927     __ Addu(target, target, Operand(Code::kHeaderSize - kHeapObjectTag));
3928     __ Call(target);
3929   }
3930   generator.AfterCall();
3931 }
3932
3933
3934 void LCodeGen::DoCallJSFunction(LCallJSFunction* instr) {
3935   ASSERT(ToRegister(instr->function()).is(a1));
3936   ASSERT(ToRegister(instr->result()).is(v0));
3937
3938   if (instr->hydrogen()->pass_argument_count()) {
3939     __ li(a0, Operand(instr->arity()));
3940   }
3941
3942   // Change context.
3943   __ lw(cp, FieldMemOperand(a1, JSFunction::kContextOffset));
3944
3945   // Load the code entry address
3946   __ lw(at, FieldMemOperand(a1, JSFunction::kCodeEntryOffset));
3947   __ Call(at);
3948
3949   RecordSafepointWithLazyDeopt(instr, RECORD_SIMPLE_SAFEPOINT);
3950 }
3951
3952
3953 void LCodeGen::DoCallFunction(LCallFunction* instr) {
3954   ASSERT(ToRegister(instr->context()).is(cp));
3955   ASSERT(ToRegister(instr->function()).is(a1));
3956   ASSERT(ToRegister(instr->result()).is(v0));
3957
3958   int arity = instr->arity();
3959   CallFunctionStub stub(isolate(), arity, instr->hydrogen()->function_flags());
3960   CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr);
3961 }
3962
3963
3964 void LCodeGen::DoCallNew(LCallNew* instr) {
3965   ASSERT(ToRegister(instr->context()).is(cp));
3966   ASSERT(ToRegister(instr->constructor()).is(a1));
3967   ASSERT(ToRegister(instr->result()).is(v0));
3968
3969   __ li(a0, Operand(instr->arity()));
3970   // No cell in a2 for construct type feedback in optimized code
3971   __ LoadRoot(a2, Heap::kUndefinedValueRootIndex);
3972   CallConstructStub stub(isolate(), NO_CALL_CONSTRUCTOR_FLAGS);
3973   CallCode(stub.GetCode(), RelocInfo::CONSTRUCT_CALL, instr);
3974 }
3975
3976
3977 void LCodeGen::DoCallNewArray(LCallNewArray* instr) {
3978   ASSERT(ToRegister(instr->context()).is(cp));
3979   ASSERT(ToRegister(instr->constructor()).is(a1));
3980   ASSERT(ToRegister(instr->result()).is(v0));
3981
3982   __ li(a0, Operand(instr->arity()));
3983   __ LoadRoot(a2, Heap::kUndefinedValueRootIndex);
3984   ElementsKind kind = instr->hydrogen()->elements_kind();
3985   AllocationSiteOverrideMode override_mode =
3986       (AllocationSite::GetMode(kind) == TRACK_ALLOCATION_SITE)
3987           ? DISABLE_ALLOCATION_SITES
3988           : DONT_OVERRIDE;
3989
3990   if (instr->arity() == 0) {
3991     ArrayNoArgumentConstructorStub stub(isolate(), kind, override_mode);
3992     CallCode(stub.GetCode(), RelocInfo::CONSTRUCT_CALL, instr);
3993   } else if (instr->arity() == 1) {
3994     Label done;
3995     if (IsFastPackedElementsKind(kind)) {
3996       Label packed_case;
3997       // We might need a change here,
3998       // look at the first argument.
3999       __ lw(t1, MemOperand(sp, 0));
4000       __ Branch(&packed_case, eq, t1, Operand(zero_reg));
4001
4002       ElementsKind holey_kind = GetHoleyElementsKind(kind);
4003       ArraySingleArgumentConstructorStub stub(isolate(),
4004                                               holey_kind,
4005                                               override_mode);
4006       CallCode(stub.GetCode(), RelocInfo::CONSTRUCT_CALL, instr);
4007       __ jmp(&done);
4008       __ bind(&packed_case);
4009     }
4010
4011     ArraySingleArgumentConstructorStub stub(isolate(), kind, override_mode);
4012     CallCode(stub.GetCode(), RelocInfo::CONSTRUCT_CALL, instr);
4013     __ bind(&done);
4014   } else {
4015     ArrayNArgumentsConstructorStub stub(isolate(), kind, override_mode);
4016     CallCode(stub.GetCode(), RelocInfo::CONSTRUCT_CALL, instr);
4017   }
4018 }
4019
4020
4021 void LCodeGen::DoCallRuntime(LCallRuntime* instr) {
4022   CallRuntime(instr->function(), instr->arity(), instr);
4023 }
4024
4025
4026 void LCodeGen::DoStoreCodeEntry(LStoreCodeEntry* instr) {
4027   Register function = ToRegister(instr->function());
4028   Register code_object = ToRegister(instr->code_object());
4029   __ Addu(code_object, code_object,
4030           Operand(Code::kHeaderSize - kHeapObjectTag));
4031   __ sw(code_object,
4032         FieldMemOperand(function, JSFunction::kCodeEntryOffset));
4033 }
4034
4035
4036 void LCodeGen::DoInnerAllocatedObject(LInnerAllocatedObject* instr) {
4037   Register result = ToRegister(instr->result());
4038   Register base = ToRegister(instr->base_object());
4039   if (instr->offset()->IsConstantOperand()) {
4040     LConstantOperand* offset = LConstantOperand::cast(instr->offset());
4041     __ Addu(result, base, Operand(ToInteger32(offset)));
4042   } else {
4043     Register offset = ToRegister(instr->offset());
4044     __ Addu(result, base, offset);
4045   }
4046 }
4047
4048
4049 void LCodeGen::DoStoreNamedField(LStoreNamedField* instr) {
4050   Representation representation = instr->representation();
4051
4052   Register object = ToRegister(instr->object());
4053   Register scratch = scratch0();
4054   HObjectAccess access = instr->hydrogen()->access();
4055   int offset = access.offset();
4056
4057   if (access.IsExternalMemory()) {
4058     Register value = ToRegister(instr->value());
4059     MemOperand operand = MemOperand(object, offset);
4060     __ Store(value, operand, representation);
4061     return;
4062   }
4063
4064   __ AssertNotSmi(object);
4065
4066   ASSERT(!representation.IsSmi() ||
4067          !instr->value()->IsConstantOperand() ||
4068          IsSmi(LConstantOperand::cast(instr->value())));
4069   if (representation.IsDouble()) {
4070     ASSERT(access.IsInobject());
4071     ASSERT(!instr->hydrogen()->has_transition());
4072     ASSERT(!instr->hydrogen()->NeedsWriteBarrier());
4073     DoubleRegister value = ToDoubleRegister(instr->value());
4074     __ sdc1(value, FieldMemOperand(object, offset));
4075     return;
4076   }
4077
4078   if (instr->hydrogen()->has_transition()) {
4079     Handle<Map> transition = instr->hydrogen()->transition_map();
4080     AddDeprecationDependency(transition);
4081     __ li(scratch, Operand(transition));
4082     __ sw(scratch, FieldMemOperand(object, HeapObject::kMapOffset));
4083     if (instr->hydrogen()->NeedsWriteBarrierForMap()) {
4084       Register temp = ToRegister(instr->temp());
4085       // Update the write barrier for the map field.
4086       __ RecordWriteForMap(object,
4087                            scratch,
4088                            temp,
4089                            GetRAState(),
4090                            kSaveFPRegs);
4091     }
4092   }
4093
4094   // Do the store.
4095   Register value = ToRegister(instr->value());
4096   if (access.IsInobject()) {
4097     MemOperand operand = FieldMemOperand(object, offset);
4098     __ Store(value, operand, representation);
4099     if (instr->hydrogen()->NeedsWriteBarrier()) {
4100       // Update the write barrier for the object for in-object properties.
4101       __ RecordWriteField(object,
4102                           offset,
4103                           value,
4104                           scratch,
4105                           GetRAState(),
4106                           kSaveFPRegs,
4107                           EMIT_REMEMBERED_SET,
4108                           instr->hydrogen()->SmiCheckForWriteBarrier(),
4109                           instr->hydrogen()->PointersToHereCheckForValue());
4110     }
4111   } else {
4112     __ lw(scratch, FieldMemOperand(object, JSObject::kPropertiesOffset));
4113     MemOperand operand = FieldMemOperand(scratch, offset);
4114     __ Store(value, operand, representation);
4115     if (instr->hydrogen()->NeedsWriteBarrier()) {
4116       // Update the write barrier for the properties array.
4117       // object is used as a scratch register.
4118       __ RecordWriteField(scratch,
4119                           offset,
4120                           value,
4121                           object,
4122                           GetRAState(),
4123                           kSaveFPRegs,
4124                           EMIT_REMEMBERED_SET,
4125                           instr->hydrogen()->SmiCheckForWriteBarrier(),
4126                           instr->hydrogen()->PointersToHereCheckForValue());
4127     }
4128   }
4129 }
4130
4131
4132 void LCodeGen::DoStoreNamedGeneric(LStoreNamedGeneric* instr) {
4133   ASSERT(ToRegister(instr->context()).is(cp));
4134   ASSERT(ToRegister(instr->object()).is(a1));
4135   ASSERT(ToRegister(instr->value()).is(a0));
4136
4137   // Name is always in a2.
4138   __ li(a2, Operand(instr->name()));
4139   Handle<Code> ic = StoreIC::initialize_stub(isolate(), instr->strict_mode());
4140   CallCode(ic, RelocInfo::CODE_TARGET, instr);
4141 }
4142
4143
4144 void LCodeGen::DoBoundsCheck(LBoundsCheck* instr) {
4145   Condition cc = instr->hydrogen()->allow_equality() ? hi : hs;
4146   Operand operand(0);
4147   Register reg;
4148   if (instr->index()->IsConstantOperand()) {
4149     operand = ToOperand(instr->index());
4150     reg = ToRegister(instr->length());
4151     cc = CommuteCondition(cc);
4152   } else {
4153     reg = ToRegister(instr->index());
4154     operand = ToOperand(instr->length());
4155   }
4156   if (FLAG_debug_code && instr->hydrogen()->skip_check()) {
4157     Label done;
4158     __ Branch(&done, NegateCondition(cc), reg, operand);
4159     __ stop("eliminated bounds check failed");
4160     __ bind(&done);
4161   } else {
4162     DeoptimizeIf(cc, instr->environment(), reg, operand);
4163   }
4164 }
4165
4166
4167 void LCodeGen::DoStoreKeyedExternalArray(LStoreKeyed* instr) {
4168   Register external_pointer = ToRegister(instr->elements());
4169   Register key = no_reg;
4170   ElementsKind elements_kind = instr->elements_kind();
4171   bool key_is_constant = instr->key()->IsConstantOperand();
4172   int constant_key = 0;
4173   if (key_is_constant) {
4174     constant_key = ToInteger32(LConstantOperand::cast(instr->key()));
4175     if (constant_key & 0xF0000000) {
4176       Abort(kArrayIndexConstantValueTooBig);
4177     }
4178   } else {
4179     key = ToRegister(instr->key());
4180   }
4181   int element_size_shift = ElementsKindToShiftSize(elements_kind);
4182   int shift_size = (instr->hydrogen()->key()->representation().IsSmi())
4183       ? (element_size_shift - kSmiTagSize) : element_size_shift;
4184   int base_offset = instr->base_offset();
4185
4186   if (elements_kind == EXTERNAL_FLOAT32_ELEMENTS ||
4187       elements_kind == FLOAT32_ELEMENTS ||
4188       elements_kind == EXTERNAL_FLOAT64_ELEMENTS ||
4189       elements_kind == FLOAT64_ELEMENTS) {
4190     Register address = scratch0();
4191     FPURegister value(ToDoubleRegister(instr->value()));
4192     if (key_is_constant) {
4193       if (constant_key != 0) {
4194         __ Addu(address, external_pointer,
4195                 Operand(constant_key << element_size_shift));
4196       } else {
4197         address = external_pointer;
4198       }
4199     } else {
4200       __ sll(address, key, shift_size);
4201       __ Addu(address, external_pointer, address);
4202     }
4203
4204     if (elements_kind == EXTERNAL_FLOAT32_ELEMENTS ||
4205         elements_kind == FLOAT32_ELEMENTS) {
4206       __ cvt_s_d(double_scratch0(), value);
4207       __ swc1(double_scratch0(), MemOperand(address, base_offset));
4208     } else {  // Storing doubles, not floats.
4209       __ sdc1(value, MemOperand(address, base_offset));
4210     }
4211   } else {
4212     Register value(ToRegister(instr->value()));
4213     MemOperand mem_operand = PrepareKeyedOperand(
4214         key, external_pointer, key_is_constant, constant_key,
4215         element_size_shift, shift_size,
4216         base_offset);
4217     switch (elements_kind) {
4218       case EXTERNAL_UINT8_CLAMPED_ELEMENTS:
4219       case EXTERNAL_INT8_ELEMENTS:
4220       case EXTERNAL_UINT8_ELEMENTS:
4221       case UINT8_ELEMENTS:
4222       case UINT8_CLAMPED_ELEMENTS:
4223       case INT8_ELEMENTS:
4224         __ sb(value, mem_operand);
4225         break;
4226       case EXTERNAL_INT16_ELEMENTS:
4227       case EXTERNAL_UINT16_ELEMENTS:
4228       case INT16_ELEMENTS:
4229       case UINT16_ELEMENTS:
4230         __ sh(value, mem_operand);
4231         break;
4232       case EXTERNAL_INT32_ELEMENTS:
4233       case EXTERNAL_UINT32_ELEMENTS:
4234       case INT32_ELEMENTS:
4235       case UINT32_ELEMENTS:
4236         __ sw(value, mem_operand);
4237         break;
4238       case FLOAT32_ELEMENTS:
4239       case FLOAT64_ELEMENTS:
4240       case EXTERNAL_FLOAT32_ELEMENTS:
4241       case EXTERNAL_FLOAT64_ELEMENTS:
4242       case FAST_DOUBLE_ELEMENTS:
4243       case FAST_ELEMENTS:
4244       case FAST_SMI_ELEMENTS:
4245       case FAST_HOLEY_DOUBLE_ELEMENTS:
4246       case FAST_HOLEY_ELEMENTS:
4247       case FAST_HOLEY_SMI_ELEMENTS:
4248       case DICTIONARY_ELEMENTS:
4249       case SLOPPY_ARGUMENTS_ELEMENTS:
4250         UNREACHABLE();
4251         break;
4252     }
4253   }
4254 }
4255
4256
4257 void LCodeGen::DoStoreKeyedFixedDoubleArray(LStoreKeyed* instr) {
4258   DoubleRegister value = ToDoubleRegister(instr->value());
4259   Register elements = ToRegister(instr->elements());
4260   Register scratch = scratch0();
4261   DoubleRegister double_scratch = double_scratch0();
4262   bool key_is_constant = instr->key()->IsConstantOperand();
4263   int base_offset = instr->base_offset();
4264   Label not_nan, done;
4265
4266   // Calculate the effective address of the slot in the array to store the
4267   // double value.
4268   int element_size_shift = ElementsKindToShiftSize(FAST_DOUBLE_ELEMENTS);
4269   if (key_is_constant) {
4270     int constant_key = ToInteger32(LConstantOperand::cast(instr->key()));
4271     if (constant_key & 0xF0000000) {
4272       Abort(kArrayIndexConstantValueTooBig);
4273     }
4274     __ Addu(scratch, elements,
4275            Operand((constant_key << element_size_shift) + base_offset));
4276   } else {
4277     int shift_size = (instr->hydrogen()->key()->representation().IsSmi())
4278         ? (element_size_shift - kSmiTagSize) : element_size_shift;
4279     __ Addu(scratch, elements, Operand(base_offset));
4280     __ sll(at, ToRegister(instr->key()), shift_size);
4281     __ Addu(scratch, scratch, at);
4282   }
4283
4284   if (instr->NeedsCanonicalization()) {
4285     Label is_nan;
4286     // Check for NaN. All NaNs must be canonicalized.
4287     __ BranchF(NULL, &is_nan, eq, value, value);
4288     __ Branch(&not_nan);
4289
4290     // Only load canonical NaN if the comparison above set the overflow.
4291     __ bind(&is_nan);
4292     __ LoadRoot(at, Heap::kNanValueRootIndex);
4293     __ ldc1(double_scratch, FieldMemOperand(at, HeapNumber::kValueOffset));
4294     __ sdc1(double_scratch, MemOperand(scratch, 0));
4295     __ Branch(&done);
4296   }
4297
4298   __ bind(&not_nan);
4299   __ sdc1(value, MemOperand(scratch, 0));
4300   __ bind(&done);
4301 }
4302
4303
4304 void LCodeGen::DoStoreKeyedFixedArray(LStoreKeyed* instr) {
4305   Register value = ToRegister(instr->value());
4306   Register elements = ToRegister(instr->elements());
4307   Register key = instr->key()->IsRegister() ? ToRegister(instr->key())
4308       : no_reg;
4309   Register scratch = scratch0();
4310   Register store_base = scratch;
4311   int offset = instr->base_offset();
4312
4313   // Do the store.
4314   if (instr->key()->IsConstantOperand()) {
4315     ASSERT(!instr->hydrogen()->NeedsWriteBarrier());
4316     LConstantOperand* const_operand = LConstantOperand::cast(instr->key());
4317     offset += ToInteger32(const_operand) * kPointerSize;
4318     store_base = elements;
4319   } else {
4320     // Even though the HLoadKeyed instruction forces the input
4321     // representation for the key to be an integer, the input gets replaced
4322     // during bound check elimination with the index argument to the bounds
4323     // check, which can be tagged, so that case must be handled here, too.
4324     if (instr->hydrogen()->key()->representation().IsSmi()) {
4325       __ sll(scratch, key, kPointerSizeLog2 - kSmiTagSize);
4326       __ addu(scratch, elements, scratch);
4327     } else {
4328       __ sll(scratch, key, kPointerSizeLog2);
4329       __ addu(scratch, elements, scratch);
4330     }
4331   }
4332   __ sw(value, MemOperand(store_base, offset));
4333
4334   if (instr->hydrogen()->NeedsWriteBarrier()) {
4335     SmiCheck check_needed =
4336         instr->hydrogen()->value()->type().IsHeapObject()
4337             ? OMIT_SMI_CHECK : INLINE_SMI_CHECK;
4338     // Compute address of modified element and store it into key register.
4339     __ Addu(key, store_base, Operand(offset));
4340     __ RecordWrite(elements,
4341                    key,
4342                    value,
4343                    GetRAState(),
4344                    kSaveFPRegs,
4345                    EMIT_REMEMBERED_SET,
4346                    check_needed,
4347                    instr->hydrogen()->PointersToHereCheckForValue());
4348   }
4349 }
4350
4351
4352 void LCodeGen::DoStoreKeyed(LStoreKeyed* instr) {
4353   // By cases: external, fast double
4354   if (instr->is_typed_elements()) {
4355     DoStoreKeyedExternalArray(instr);
4356   } else if (instr->hydrogen()->value()->representation().IsDouble()) {
4357     DoStoreKeyedFixedDoubleArray(instr);
4358   } else {
4359     DoStoreKeyedFixedArray(instr);
4360   }
4361 }
4362
4363
4364 void LCodeGen::DoStoreKeyedGeneric(LStoreKeyedGeneric* instr) {
4365   ASSERT(ToRegister(instr->context()).is(cp));
4366   ASSERT(ToRegister(instr->object()).is(a2));
4367   ASSERT(ToRegister(instr->key()).is(a1));
4368   ASSERT(ToRegister(instr->value()).is(a0));
4369
4370   Handle<Code> ic = (instr->strict_mode() == STRICT)
4371       ? isolate()->builtins()->KeyedStoreIC_Initialize_Strict()
4372       : isolate()->builtins()->KeyedStoreIC_Initialize();
4373   CallCode(ic, RelocInfo::CODE_TARGET, instr);
4374 }
4375
4376
4377 void LCodeGen::DoTransitionElementsKind(LTransitionElementsKind* instr) {
4378   Register object_reg = ToRegister(instr->object());
4379   Register scratch = scratch0();
4380
4381   Handle<Map> from_map = instr->original_map();
4382   Handle<Map> to_map = instr->transitioned_map();
4383   ElementsKind from_kind = instr->from_kind();
4384   ElementsKind to_kind = instr->to_kind();
4385
4386   Label not_applicable;
4387   __ lw(scratch, FieldMemOperand(object_reg, HeapObject::kMapOffset));
4388   __ Branch(&not_applicable, ne, scratch, Operand(from_map));
4389
4390   if (IsSimpleMapChangeTransition(from_kind, to_kind)) {
4391     Register new_map_reg = ToRegister(instr->new_map_temp());
4392     __ li(new_map_reg, Operand(to_map));
4393     __ sw(new_map_reg, FieldMemOperand(object_reg, HeapObject::kMapOffset));
4394     // Write barrier.
4395     __ RecordWriteForMap(object_reg,
4396                          new_map_reg,
4397                          scratch,
4398                          GetRAState(),
4399                          kDontSaveFPRegs);
4400   } else {
4401     ASSERT(object_reg.is(a0));
4402     ASSERT(ToRegister(instr->context()).is(cp));
4403     PushSafepointRegistersScope scope(
4404         this, Safepoint::kWithRegistersAndDoubles);
4405     __ li(a1, Operand(to_map));
4406     bool is_js_array = from_map->instance_type() == JS_ARRAY_TYPE;
4407     TransitionElementsKindStub stub(isolate(), from_kind, to_kind, is_js_array);
4408     __ CallStub(&stub);
4409     RecordSafepointWithRegistersAndDoubles(
4410         instr->pointer_map(), 0, Safepoint::kLazyDeopt);
4411   }
4412   __ bind(&not_applicable);
4413 }
4414
4415
4416 void LCodeGen::DoTrapAllocationMemento(LTrapAllocationMemento* instr) {
4417   Register object = ToRegister(instr->object());
4418   Register temp = ToRegister(instr->temp());
4419   Label no_memento_found;
4420   __ TestJSArrayForAllocationMemento(object, temp, &no_memento_found,
4421                                      ne, &no_memento_found);
4422   DeoptimizeIf(al, instr->environment());
4423   __ bind(&no_memento_found);
4424 }
4425
4426
4427 void LCodeGen::DoStringAdd(LStringAdd* instr) {
4428   ASSERT(ToRegister(instr->context()).is(cp));
4429   ASSERT(ToRegister(instr->left()).is(a1));
4430   ASSERT(ToRegister(instr->right()).is(a0));
4431   StringAddStub stub(isolate(),
4432                      instr->hydrogen()->flags(),
4433                      instr->hydrogen()->pretenure_flag());
4434   CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr);
4435 }
4436
4437
4438 void LCodeGen::DoStringCharCodeAt(LStringCharCodeAt* instr) {
4439   class DeferredStringCharCodeAt V8_FINAL : public LDeferredCode {
4440    public:
4441     DeferredStringCharCodeAt(LCodeGen* codegen, LStringCharCodeAt* instr)
4442         : LDeferredCode(codegen), instr_(instr) { }
4443     virtual void Generate() V8_OVERRIDE {
4444       codegen()->DoDeferredStringCharCodeAt(instr_);
4445     }
4446     virtual LInstruction* instr() V8_OVERRIDE { return instr_; }
4447    private:
4448     LStringCharCodeAt* instr_;
4449   };
4450
4451   DeferredStringCharCodeAt* deferred =
4452       new(zone()) DeferredStringCharCodeAt(this, instr);
4453   StringCharLoadGenerator::Generate(masm(),
4454                                     ToRegister(instr->string()),
4455                                     ToRegister(instr->index()),
4456                                     ToRegister(instr->result()),
4457                                     deferred->entry());
4458   __ bind(deferred->exit());
4459 }
4460
4461
4462 void LCodeGen::DoDeferredStringCharCodeAt(LStringCharCodeAt* instr) {
4463   Register string = ToRegister(instr->string());
4464   Register result = ToRegister(instr->result());
4465   Register scratch = scratch0();
4466
4467   // TODO(3095996): Get rid of this. For now, we need to make the
4468   // result register contain a valid pointer because it is already
4469   // contained in the register pointer map.
4470   __ mov(result, zero_reg);
4471
4472   PushSafepointRegistersScope scope(this, Safepoint::kWithRegisters);
4473   __ push(string);
4474   // Push the index as a smi. This is safe because of the checks in
4475   // DoStringCharCodeAt above.
4476   if (instr->index()->IsConstantOperand()) {
4477     int const_index = ToInteger32(LConstantOperand::cast(instr->index()));
4478     __ Addu(scratch, zero_reg, Operand(Smi::FromInt(const_index)));
4479     __ push(scratch);
4480   } else {
4481     Register index = ToRegister(instr->index());
4482     __ SmiTag(index);
4483     __ push(index);
4484   }
4485   CallRuntimeFromDeferred(Runtime::kHiddenStringCharCodeAt, 2, instr,
4486                           instr->context());
4487   __ AssertSmi(v0);
4488   __ SmiUntag(v0);
4489   __ StoreToSafepointRegisterSlot(v0, result);
4490 }
4491
4492
4493 void LCodeGen::DoStringCharFromCode(LStringCharFromCode* instr) {
4494   class DeferredStringCharFromCode V8_FINAL : public LDeferredCode {
4495    public:
4496     DeferredStringCharFromCode(LCodeGen* codegen, LStringCharFromCode* instr)
4497         : LDeferredCode(codegen), instr_(instr) { }
4498     virtual void Generate() V8_OVERRIDE {
4499       codegen()->DoDeferredStringCharFromCode(instr_);
4500     }
4501     virtual LInstruction* instr() V8_OVERRIDE { return instr_; }
4502    private:
4503     LStringCharFromCode* instr_;
4504   };
4505
4506   DeferredStringCharFromCode* deferred =
4507       new(zone()) DeferredStringCharFromCode(this, instr);
4508
4509   ASSERT(instr->hydrogen()->value()->representation().IsInteger32());
4510   Register char_code = ToRegister(instr->char_code());
4511   Register result = ToRegister(instr->result());
4512   Register scratch = scratch0();
4513   ASSERT(!char_code.is(result));
4514
4515   __ Branch(deferred->entry(), hi,
4516             char_code, Operand(String::kMaxOneByteCharCode));
4517   __ LoadRoot(result, Heap::kSingleCharacterStringCacheRootIndex);
4518   __ sll(scratch, char_code, kPointerSizeLog2);
4519   __ Addu(result, result, scratch);
4520   __ lw(result, FieldMemOperand(result, FixedArray::kHeaderSize));
4521   __ LoadRoot(scratch, Heap::kUndefinedValueRootIndex);
4522   __ Branch(deferred->entry(), eq, result, Operand(scratch));
4523   __ bind(deferred->exit());
4524 }
4525
4526
4527 void LCodeGen::DoDeferredStringCharFromCode(LStringCharFromCode* instr) {
4528   Register char_code = ToRegister(instr->char_code());
4529   Register result = ToRegister(instr->result());
4530
4531   // TODO(3095996): Get rid of this. For now, we need to make the
4532   // result register contain a valid pointer because it is already
4533   // contained in the register pointer map.
4534   __ mov(result, zero_reg);
4535
4536   PushSafepointRegistersScope scope(this, Safepoint::kWithRegisters);
4537   __ SmiTag(char_code);
4538   __ push(char_code);
4539   CallRuntimeFromDeferred(Runtime::kCharFromCode, 1, instr, instr->context());
4540   __ StoreToSafepointRegisterSlot(v0, result);
4541 }
4542
4543
4544 void LCodeGen::DoInteger32ToDouble(LInteger32ToDouble* instr) {
4545   LOperand* input = instr->value();
4546   ASSERT(input->IsRegister() || input->IsStackSlot());
4547   LOperand* output = instr->result();
4548   ASSERT(output->IsDoubleRegister());
4549   FPURegister single_scratch = double_scratch0().low();
4550   if (input->IsStackSlot()) {
4551     Register scratch = scratch0();
4552     __ lw(scratch, ToMemOperand(input));
4553     __ mtc1(scratch, single_scratch);
4554   } else {
4555     __ mtc1(ToRegister(input), single_scratch);
4556   }
4557   __ cvt_d_w(ToDoubleRegister(output), single_scratch);
4558 }
4559
4560
4561 void LCodeGen::DoUint32ToDouble(LUint32ToDouble* instr) {
4562   LOperand* input = instr->value();
4563   LOperand* output = instr->result();
4564
4565   FPURegister dbl_scratch = double_scratch0();
4566   __ mtc1(ToRegister(input), dbl_scratch);
4567   __ Cvt_d_uw(ToDoubleRegister(output), dbl_scratch, f22);
4568 }
4569
4570
4571 void LCodeGen::DoNumberTagI(LNumberTagI* instr) {
4572   class DeferredNumberTagI V8_FINAL : public LDeferredCode {
4573    public:
4574     DeferredNumberTagI(LCodeGen* codegen, LNumberTagI* instr)
4575         : LDeferredCode(codegen), instr_(instr) { }
4576     virtual void Generate() V8_OVERRIDE {
4577       codegen()->DoDeferredNumberTagIU(instr_,
4578                                        instr_->value(),
4579                                        instr_->temp1(),
4580                                        instr_->temp2(),
4581                                        SIGNED_INT32);
4582     }
4583     virtual LInstruction* instr() V8_OVERRIDE { return instr_; }
4584    private:
4585     LNumberTagI* instr_;
4586   };
4587
4588   Register src = ToRegister(instr->value());
4589   Register dst = ToRegister(instr->result());
4590   Register overflow = scratch0();
4591
4592   DeferredNumberTagI* deferred = new(zone()) DeferredNumberTagI(this, instr);
4593   __ SmiTagCheckOverflow(dst, src, overflow);
4594   __ BranchOnOverflow(deferred->entry(), overflow);
4595   __ bind(deferred->exit());
4596 }
4597
4598
4599 void LCodeGen::DoNumberTagU(LNumberTagU* instr) {
4600   class DeferredNumberTagU V8_FINAL : public LDeferredCode {
4601    public:
4602     DeferredNumberTagU(LCodeGen* codegen, LNumberTagU* instr)
4603         : LDeferredCode(codegen), instr_(instr) { }
4604     virtual void Generate() V8_OVERRIDE {
4605       codegen()->DoDeferredNumberTagIU(instr_,
4606                                        instr_->value(),
4607                                        instr_->temp1(),
4608                                        instr_->temp2(),
4609                                        UNSIGNED_INT32);
4610     }
4611     virtual LInstruction* instr() V8_OVERRIDE { return instr_; }
4612    private:
4613     LNumberTagU* instr_;
4614   };
4615
4616   Register input = ToRegister(instr->value());
4617   Register result = ToRegister(instr->result());
4618
4619   DeferredNumberTagU* deferred = new(zone()) DeferredNumberTagU(this, instr);
4620   __ Branch(deferred->entry(), hi, input, Operand(Smi::kMaxValue));
4621   __ SmiTag(result, input);
4622   __ bind(deferred->exit());
4623 }
4624
4625
4626 void LCodeGen::DoDeferredNumberTagIU(LInstruction* instr,
4627                                      LOperand* value,
4628                                      LOperand* temp1,
4629                                      LOperand* temp2,
4630                                      IntegerSignedness signedness) {
4631   Label done, slow;
4632   Register src = ToRegister(value);
4633   Register dst = ToRegister(instr->result());
4634   Register tmp1 = scratch0();
4635   Register tmp2 = ToRegister(temp1);
4636   Register tmp3 = ToRegister(temp2);
4637   DoubleRegister dbl_scratch = double_scratch0();
4638
4639   if (signedness == SIGNED_INT32) {
4640     // There was overflow, so bits 30 and 31 of the original integer
4641     // disagree. Try to allocate a heap number in new space and store
4642     // the value in there. If that fails, call the runtime system.
4643     if (dst.is(src)) {
4644       __ SmiUntag(src, dst);
4645       __ Xor(src, src, Operand(0x80000000));
4646     }
4647     __ mtc1(src, dbl_scratch);
4648     __ cvt_d_w(dbl_scratch, dbl_scratch);
4649   } else {
4650     __ mtc1(src, dbl_scratch);
4651     __ Cvt_d_uw(dbl_scratch, dbl_scratch, f22);
4652   }
4653
4654   if (FLAG_inline_new) {
4655     __ LoadRoot(tmp3, Heap::kHeapNumberMapRootIndex);
4656     __ AllocateHeapNumber(dst, tmp1, tmp2, tmp3, &slow, DONT_TAG_RESULT);
4657     __ Branch(&done);
4658   }
4659
4660   // Slow case: Call the runtime system to do the number allocation.
4661   __ bind(&slow);
4662   {
4663     // TODO(3095996): Put a valid pointer value in the stack slot where the
4664     // result register is stored, as this register is in the pointer map, but
4665     // contains an integer value.
4666     __ mov(dst, zero_reg);
4667
4668     // Preserve the value of all registers.
4669     PushSafepointRegistersScope scope(this, Safepoint::kWithRegisters);
4670
4671     // NumberTagI and NumberTagD use the context from the frame, rather than
4672     // the environment's HContext or HInlinedContext value.
4673     // They only call Runtime::kHiddenAllocateHeapNumber.
4674     // The corresponding HChange instructions are added in a phase that does
4675     // not have easy access to the local context.
4676     __ lw(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
4677     __ CallRuntimeSaveDoubles(Runtime::kHiddenAllocateHeapNumber);
4678     RecordSafepointWithRegisters(
4679         instr->pointer_map(), 0, Safepoint::kNoLazyDeopt);
4680     __ Subu(v0, v0, kHeapObjectTag);
4681     __ StoreToSafepointRegisterSlot(v0, dst);
4682   }
4683
4684
4685   // Done. Put the value in dbl_scratch into the value of the allocated heap
4686   // number.
4687   __ bind(&done);
4688   __ sdc1(dbl_scratch, MemOperand(dst, HeapNumber::kValueOffset));
4689   __ Addu(dst, dst, kHeapObjectTag);
4690 }
4691
4692
4693 void LCodeGen::DoNumberTagD(LNumberTagD* instr) {
4694   class DeferredNumberTagD V8_FINAL : public LDeferredCode {
4695    public:
4696     DeferredNumberTagD(LCodeGen* codegen, LNumberTagD* instr)
4697         : LDeferredCode(codegen), instr_(instr) { }
4698     virtual void Generate() V8_OVERRIDE {
4699       codegen()->DoDeferredNumberTagD(instr_);
4700     }
4701     virtual LInstruction* instr() V8_OVERRIDE { return instr_; }
4702    private:
4703     LNumberTagD* instr_;
4704   };
4705
4706   DoubleRegister input_reg = ToDoubleRegister(instr->value());
4707   Register scratch = scratch0();
4708   Register reg = ToRegister(instr->result());
4709   Register temp1 = ToRegister(instr->temp());
4710   Register temp2 = ToRegister(instr->temp2());
4711
4712   DeferredNumberTagD* deferred = new(zone()) DeferredNumberTagD(this, instr);
4713   if (FLAG_inline_new) {
4714     __ LoadRoot(scratch, Heap::kHeapNumberMapRootIndex);
4715     // We want the untagged address first for performance
4716     __ AllocateHeapNumber(reg, temp1, temp2, scratch, deferred->entry(),
4717                           DONT_TAG_RESULT);
4718   } else {
4719     __ Branch(deferred->entry());
4720   }
4721   __ bind(deferred->exit());
4722   __ sdc1(input_reg, MemOperand(reg, HeapNumber::kValueOffset));
4723   // Now that we have finished with the object's real address tag it
4724   __ Addu(reg, reg, kHeapObjectTag);
4725 }
4726
4727
4728 void LCodeGen::DoDeferredNumberTagD(LNumberTagD* instr) {
4729   // TODO(3095996): Get rid of this. For now, we need to make the
4730   // result register contain a valid pointer because it is already
4731   // contained in the register pointer map.
4732   Register reg = ToRegister(instr->result());
4733   __ mov(reg, zero_reg);
4734
4735   PushSafepointRegistersScope scope(this, Safepoint::kWithRegisters);
4736   // NumberTagI and NumberTagD use the context from the frame, rather than
4737   // the environment's HContext or HInlinedContext value.
4738   // They only call Runtime::kHiddenAllocateHeapNumber.
4739   // The corresponding HChange instructions are added in a phase that does
4740   // not have easy access to the local context.
4741   __ lw(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
4742   __ CallRuntimeSaveDoubles(Runtime::kHiddenAllocateHeapNumber);
4743   RecordSafepointWithRegisters(
4744       instr->pointer_map(), 0, Safepoint::kNoLazyDeopt);
4745   __ Subu(v0, v0, kHeapObjectTag);
4746   __ StoreToSafepointRegisterSlot(v0, reg);
4747 }
4748
4749
4750 void LCodeGen::DoSmiTag(LSmiTag* instr) {
4751   HChange* hchange = instr->hydrogen();
4752   Register input = ToRegister(instr->value());
4753   Register output = ToRegister(instr->result());
4754   if (hchange->CheckFlag(HValue::kCanOverflow) &&
4755       hchange->value()->CheckFlag(HValue::kUint32)) {
4756     __ And(at, input, Operand(0xc0000000));
4757     DeoptimizeIf(ne, instr->environment(), at, Operand(zero_reg));
4758   }
4759   if (hchange->CheckFlag(HValue::kCanOverflow) &&
4760       !hchange->value()->CheckFlag(HValue::kUint32)) {
4761     __ SmiTagCheckOverflow(output, input, at);
4762     DeoptimizeIf(lt, instr->environment(), at, Operand(zero_reg));
4763   } else {
4764     __ SmiTag(output, input);
4765   }
4766 }
4767
4768
4769 void LCodeGen::DoSmiUntag(LSmiUntag* instr) {
4770   Register scratch = scratch0();
4771   Register input = ToRegister(instr->value());
4772   Register result = ToRegister(instr->result());
4773   if (instr->needs_check()) {
4774     STATIC_ASSERT(kHeapObjectTag == 1);
4775     // If the input is a HeapObject, value of scratch won't be zero.
4776     __ And(scratch, input, Operand(kHeapObjectTag));
4777     __ SmiUntag(result, input);
4778     DeoptimizeIf(ne, instr->environment(), scratch, Operand(zero_reg));
4779   } else {
4780     __ SmiUntag(result, input);
4781   }
4782 }
4783
4784
4785 void LCodeGen::EmitNumberUntagD(Register input_reg,
4786                                 DoubleRegister result_reg,
4787                                 bool can_convert_undefined_to_nan,
4788                                 bool deoptimize_on_minus_zero,
4789                                 LEnvironment* env,
4790                                 NumberUntagDMode mode) {
4791   Register scratch = scratch0();
4792   Label convert, load_smi, done;
4793   if (mode == NUMBER_CANDIDATE_IS_ANY_TAGGED) {
4794     // Smi check.
4795     __ UntagAndJumpIfSmi(scratch, input_reg, &load_smi);
4796     // Heap number map check.
4797     __ lw(scratch, FieldMemOperand(input_reg, HeapObject::kMapOffset));
4798     __ LoadRoot(at, Heap::kHeapNumberMapRootIndex);
4799     if (can_convert_undefined_to_nan) {
4800       __ Branch(&convert, ne, scratch, Operand(at));
4801     } else {
4802       DeoptimizeIf(ne, env, scratch, Operand(at));
4803     }
4804     // Load heap number.
4805     __ ldc1(result_reg, FieldMemOperand(input_reg, HeapNumber::kValueOffset));
4806     if (deoptimize_on_minus_zero) {
4807       __ mfc1(at, result_reg.low());
4808       __ Branch(&done, ne, at, Operand(zero_reg));
4809       __ mfc1(scratch, result_reg.high());
4810       DeoptimizeIf(eq, env, scratch, Operand(HeapNumber::kSignMask));
4811     }
4812     __ Branch(&done);
4813     if (can_convert_undefined_to_nan) {
4814       __ bind(&convert);
4815       // Convert undefined (and hole) to NaN.
4816       __ LoadRoot(at, Heap::kUndefinedValueRootIndex);
4817       DeoptimizeIf(ne, env, input_reg, Operand(at));
4818       __ LoadRoot(scratch, Heap::kNanValueRootIndex);
4819       __ ldc1(result_reg, FieldMemOperand(scratch, HeapNumber::kValueOffset));
4820       __ Branch(&done);
4821     }
4822   } else {
4823     __ SmiUntag(scratch, input_reg);
4824     ASSERT(mode == NUMBER_CANDIDATE_IS_SMI);
4825   }
4826   // Smi to double register conversion
4827   __ bind(&load_smi);
4828   // scratch: untagged value of input_reg
4829   __ mtc1(scratch, result_reg);
4830   __ cvt_d_w(result_reg, result_reg);
4831   __ bind(&done);
4832 }
4833
4834
4835 void LCodeGen::DoDeferredTaggedToI(LTaggedToI* instr) {
4836   Register input_reg = ToRegister(instr->value());
4837   Register scratch1 = scratch0();
4838   Register scratch2 = ToRegister(instr->temp());
4839   DoubleRegister double_scratch = double_scratch0();
4840   DoubleRegister double_scratch2 = ToDoubleRegister(instr->temp2());
4841
4842   ASSERT(!scratch1.is(input_reg) && !scratch1.is(scratch2));
4843   ASSERT(!scratch2.is(input_reg) && !scratch2.is(scratch1));
4844
4845   Label done;
4846
4847   // The input is a tagged HeapObject.
4848   // Heap number map check.
4849   __ lw(scratch1, FieldMemOperand(input_reg, HeapObject::kMapOffset));
4850   __ LoadRoot(at, Heap::kHeapNumberMapRootIndex);
4851   // This 'at' value and scratch1 map value are used for tests in both clauses
4852   // of the if.
4853
4854   if (instr->truncating()) {
4855     // Performs a truncating conversion of a floating point number as used by
4856     // the JS bitwise operations.
4857     Label no_heap_number, check_bools, check_false;
4858     // Check HeapNumber map.
4859     __ Branch(USE_DELAY_SLOT, &no_heap_number, ne, scratch1, Operand(at));
4860     __ mov(scratch2, input_reg);  // In delay slot.
4861     __ TruncateHeapNumberToI(input_reg, scratch2);
4862     __ Branch(&done);
4863
4864     // Check for Oddballs. Undefined/False is converted to zero and True to one
4865     // for truncating conversions.
4866     __ bind(&no_heap_number);
4867     __ LoadRoot(at, Heap::kUndefinedValueRootIndex);
4868     __ Branch(&check_bools, ne, input_reg, Operand(at));
4869     ASSERT(ToRegister(instr->result()).is(input_reg));
4870     __ Branch(USE_DELAY_SLOT, &done);
4871     __ mov(input_reg, zero_reg);  // In delay slot.
4872
4873     __ bind(&check_bools);
4874     __ LoadRoot(at, Heap::kTrueValueRootIndex);
4875     __ Branch(&check_false, ne, scratch2, Operand(at));
4876     __ Branch(USE_DELAY_SLOT, &done);
4877     __ li(input_reg, Operand(1));  // In delay slot.
4878
4879     __ bind(&check_false);
4880     __ LoadRoot(at, Heap::kFalseValueRootIndex);
4881     DeoptimizeIf(ne, instr->environment(), scratch2, Operand(at));
4882     __ Branch(USE_DELAY_SLOT, &done);
4883     __ mov(input_reg, zero_reg);  // In delay slot.
4884   } else {
4885     // Deoptimize if we don't have a heap number.
4886     DeoptimizeIf(ne, instr->environment(), scratch1, Operand(at));
4887
4888     // Load the double value.
4889     __ ldc1(double_scratch,
4890             FieldMemOperand(input_reg, HeapNumber::kValueOffset));
4891
4892     Register except_flag = scratch2;
4893     __ EmitFPUTruncate(kRoundToZero,
4894                        input_reg,
4895                        double_scratch,
4896                        scratch1,
4897                        double_scratch2,
4898                        except_flag,
4899                        kCheckForInexactConversion);
4900
4901     // Deopt if the operation did not succeed.
4902     DeoptimizeIf(ne, instr->environment(), except_flag, Operand(zero_reg));
4903
4904     if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
4905       __ Branch(&done, ne, input_reg, Operand(zero_reg));
4906
4907       __ mfc1(scratch1, double_scratch.high());
4908       __ And(scratch1, scratch1, Operand(HeapNumber::kSignMask));
4909       DeoptimizeIf(ne, instr->environment(), scratch1, Operand(zero_reg));
4910     }
4911   }
4912   __ bind(&done);
4913 }
4914
4915
4916 void LCodeGen::DoTaggedToI(LTaggedToI* instr) {
4917   class DeferredTaggedToI V8_FINAL : public LDeferredCode {
4918    public:
4919     DeferredTaggedToI(LCodeGen* codegen, LTaggedToI* instr)
4920         : LDeferredCode(codegen), instr_(instr) { }
4921     virtual void Generate() V8_OVERRIDE {
4922       codegen()->DoDeferredTaggedToI(instr_);
4923     }
4924     virtual LInstruction* instr() V8_OVERRIDE { return instr_; }
4925    private:
4926     LTaggedToI* instr_;
4927   };
4928
4929   LOperand* input = instr->value();
4930   ASSERT(input->IsRegister());
4931   ASSERT(input->Equals(instr->result()));
4932
4933   Register input_reg = ToRegister(input);
4934
4935   if (instr->hydrogen()->value()->representation().IsSmi()) {
4936     __ SmiUntag(input_reg);
4937   } else {
4938     DeferredTaggedToI* deferred = new(zone()) DeferredTaggedToI(this, instr);
4939
4940     // Let the deferred code handle the HeapObject case.
4941     __ JumpIfNotSmi(input_reg, deferred->entry());
4942
4943     // Smi to int32 conversion.
4944     __ SmiUntag(input_reg);
4945     __ bind(deferred->exit());
4946   }
4947 }
4948
4949
4950 void LCodeGen::DoNumberUntagD(LNumberUntagD* instr) {
4951   LOperand* input = instr->value();
4952   ASSERT(input->IsRegister());
4953   LOperand* result = instr->result();
4954   ASSERT(result->IsDoubleRegister());
4955
4956   Register input_reg = ToRegister(input);
4957   DoubleRegister result_reg = ToDoubleRegister(result);
4958
4959   HValue* value = instr->hydrogen()->value();
4960   NumberUntagDMode mode = value->representation().IsSmi()
4961       ? NUMBER_CANDIDATE_IS_SMI : NUMBER_CANDIDATE_IS_ANY_TAGGED;
4962
4963   EmitNumberUntagD(input_reg, result_reg,
4964                    instr->hydrogen()->can_convert_undefined_to_nan(),
4965                    instr->hydrogen()->deoptimize_on_minus_zero(),
4966                    instr->environment(),
4967                    mode);
4968 }
4969
4970
4971 void LCodeGen::DoDoubleToI(LDoubleToI* instr) {
4972   Register result_reg = ToRegister(instr->result());
4973   Register scratch1 = scratch0();
4974   DoubleRegister double_input = ToDoubleRegister(instr->value());
4975
4976   if (instr->truncating()) {
4977     __ TruncateDoubleToI(result_reg, double_input);
4978   } else {
4979     Register except_flag = LCodeGen::scratch1();
4980
4981     __ EmitFPUTruncate(kRoundToMinusInf,
4982                        result_reg,
4983                        double_input,
4984                        scratch1,
4985                        double_scratch0(),
4986                        except_flag,
4987                        kCheckForInexactConversion);
4988
4989     // Deopt if the operation did not succeed (except_flag != 0).
4990     DeoptimizeIf(ne, instr->environment(), except_flag, Operand(zero_reg));
4991
4992     if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
4993       Label done;
4994       __ Branch(&done, ne, result_reg, Operand(zero_reg));
4995       __ mfc1(scratch1, double_input.high());
4996       __ And(scratch1, scratch1, Operand(HeapNumber::kSignMask));
4997       DeoptimizeIf(ne, instr->environment(), scratch1, Operand(zero_reg));
4998       __ bind(&done);
4999     }
5000   }
5001 }
5002
5003
5004 void LCodeGen::DoDoubleToSmi(LDoubleToSmi* instr) {
5005   Register result_reg = ToRegister(instr->result());
5006   Register scratch1 = LCodeGen::scratch0();
5007   DoubleRegister double_input = ToDoubleRegister(instr->value());
5008
5009   if (instr->truncating()) {
5010     __ TruncateDoubleToI(result_reg, double_input);
5011   } else {
5012     Register except_flag = LCodeGen::scratch1();
5013
5014     __ EmitFPUTruncate(kRoundToMinusInf,
5015                        result_reg,
5016                        double_input,
5017                        scratch1,
5018                        double_scratch0(),
5019                        except_flag,
5020                        kCheckForInexactConversion);
5021
5022     // Deopt if the operation did not succeed (except_flag != 0).
5023     DeoptimizeIf(ne, instr->environment(), except_flag, Operand(zero_reg));
5024
5025     if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
5026       Label done;
5027       __ Branch(&done, ne, result_reg, Operand(zero_reg));
5028       __ mfc1(scratch1, double_input.high());
5029       __ And(scratch1, scratch1, Operand(HeapNumber::kSignMask));
5030       DeoptimizeIf(ne, instr->environment(), scratch1, Operand(zero_reg));
5031       __ bind(&done);
5032     }
5033   }
5034   __ SmiTagCheckOverflow(result_reg, result_reg, scratch1);
5035   DeoptimizeIf(lt, instr->environment(), scratch1, Operand(zero_reg));
5036 }
5037
5038
5039 void LCodeGen::DoCheckSmi(LCheckSmi* instr) {
5040   LOperand* input = instr->value();
5041   __ SmiTst(ToRegister(input), at);
5042   DeoptimizeIf(ne, instr->environment(), at, Operand(zero_reg));
5043 }
5044
5045
5046 void LCodeGen::DoCheckNonSmi(LCheckNonSmi* instr) {
5047   if (!instr->hydrogen()->value()->type().IsHeapObject()) {
5048     LOperand* input = instr->value();
5049     __ SmiTst(ToRegister(input), at);
5050     DeoptimizeIf(eq, instr->environment(), at, Operand(zero_reg));
5051   }
5052 }
5053
5054
5055 void LCodeGen::DoCheckInstanceType(LCheckInstanceType* instr) {
5056   Register input = ToRegister(instr->value());
5057   Register scratch = scratch0();
5058
5059   __ GetObjectType(input, scratch, scratch);
5060
5061   if (instr->hydrogen()->is_interval_check()) {
5062     InstanceType first;
5063     InstanceType last;
5064     instr->hydrogen()->GetCheckInterval(&first, &last);
5065
5066     // If there is only one type in the interval check for equality.
5067     if (first == last) {
5068       DeoptimizeIf(ne, instr->environment(), scratch, Operand(first));
5069     } else {
5070       DeoptimizeIf(lo, instr->environment(), scratch, Operand(first));
5071       // Omit check for the last type.
5072       if (last != LAST_TYPE) {
5073         DeoptimizeIf(hi, instr->environment(), scratch, Operand(last));
5074       }
5075     }
5076   } else {
5077     uint8_t mask;
5078     uint8_t tag;
5079     instr->hydrogen()->GetCheckMaskAndTag(&mask, &tag);
5080
5081     if (IsPowerOf2(mask)) {
5082       ASSERT(tag == 0 || IsPowerOf2(tag));
5083       __ And(at, scratch, mask);
5084       DeoptimizeIf(tag == 0 ? ne : eq, instr->environment(),
5085           at, Operand(zero_reg));
5086     } else {
5087       __ And(scratch, scratch, Operand(mask));
5088       DeoptimizeIf(ne, instr->environment(), scratch, Operand(tag));
5089     }
5090   }
5091 }
5092
5093
5094 void LCodeGen::DoCheckValue(LCheckValue* instr) {
5095   Register reg = ToRegister(instr->value());
5096   Handle<HeapObject> object = instr->hydrogen()->object().handle();
5097   AllowDeferredHandleDereference smi_check;
5098   if (isolate()->heap()->InNewSpace(*object)) {
5099     Register reg = ToRegister(instr->value());
5100     Handle<Cell> cell = isolate()->factory()->NewCell(object);
5101     __ li(at, Operand(Handle<Object>(cell)));
5102     __ lw(at, FieldMemOperand(at, Cell::kValueOffset));
5103     DeoptimizeIf(ne, instr->environment(), reg,
5104                  Operand(at));
5105   } else {
5106     DeoptimizeIf(ne, instr->environment(), reg,
5107                  Operand(object));
5108   }
5109 }
5110
5111
5112 void LCodeGen::DoDeferredInstanceMigration(LCheckMaps* instr, Register object) {
5113   {
5114     PushSafepointRegistersScope scope(this, Safepoint::kWithRegisters);
5115     __ push(object);
5116     __ mov(cp, zero_reg);
5117     __ CallRuntimeSaveDoubles(Runtime::kTryMigrateInstance);
5118     RecordSafepointWithRegisters(
5119         instr->pointer_map(), 1, Safepoint::kNoLazyDeopt);
5120     __ StoreToSafepointRegisterSlot(v0, scratch0());
5121   }
5122   __ SmiTst(scratch0(), at);
5123   DeoptimizeIf(eq, instr->environment(), at, Operand(zero_reg));
5124 }
5125
5126
5127 void LCodeGen::DoCheckMaps(LCheckMaps* instr) {
5128   class DeferredCheckMaps V8_FINAL : public LDeferredCode {
5129    public:
5130     DeferredCheckMaps(LCodeGen* codegen, LCheckMaps* instr, Register object)
5131         : LDeferredCode(codegen), instr_(instr), object_(object) {
5132       SetExit(check_maps());
5133     }
5134     virtual void Generate() V8_OVERRIDE {
5135       codegen()->DoDeferredInstanceMigration(instr_, object_);
5136     }
5137     Label* check_maps() { return &check_maps_; }
5138     virtual LInstruction* instr() V8_OVERRIDE { return instr_; }
5139    private:
5140     LCheckMaps* instr_;
5141     Label check_maps_;
5142     Register object_;
5143   };
5144
5145   if (instr->hydrogen()->IsStabilityCheck()) {
5146     const UniqueSet<Map>* maps = instr->hydrogen()->maps();
5147     for (int i = 0; i < maps->size(); ++i) {
5148       AddStabilityDependency(maps->at(i).handle());
5149     }
5150     return;
5151   }
5152
5153   Register map_reg = scratch0();
5154   LOperand* input = instr->value();
5155   ASSERT(input->IsRegister());
5156   Register reg = ToRegister(input);
5157   __ lw(map_reg, FieldMemOperand(reg, HeapObject::kMapOffset));
5158
5159   DeferredCheckMaps* deferred = NULL;
5160   if (instr->hydrogen()->HasMigrationTarget()) {
5161     deferred = new(zone()) DeferredCheckMaps(this, instr, reg);
5162     __ bind(deferred->check_maps());
5163   }
5164
5165   const UniqueSet<Map>* maps = instr->hydrogen()->maps();
5166   Label success;
5167   for (int i = 0; i < maps->size() - 1; i++) {
5168     Handle<Map> map = maps->at(i).handle();
5169     __ CompareMapAndBranch(map_reg, map, &success, eq, &success);
5170   }
5171   Handle<Map> map = maps->at(maps->size() - 1).handle();
5172   // Do the CompareMap() directly within the Branch() and DeoptimizeIf().
5173   if (instr->hydrogen()->HasMigrationTarget()) {
5174     __ Branch(deferred->entry(), ne, map_reg, Operand(map));
5175   } else {
5176     DeoptimizeIf(ne, instr->environment(), map_reg, Operand(map));
5177   }
5178
5179   __ bind(&success);
5180 }
5181
5182
5183 void LCodeGen::DoClampDToUint8(LClampDToUint8* instr) {
5184   DoubleRegister value_reg = ToDoubleRegister(instr->unclamped());
5185   Register result_reg = ToRegister(instr->result());
5186   DoubleRegister temp_reg = ToDoubleRegister(instr->temp());
5187   __ ClampDoubleToUint8(result_reg, value_reg, temp_reg);
5188 }
5189
5190
5191 void LCodeGen::DoClampIToUint8(LClampIToUint8* instr) {
5192   Register unclamped_reg = ToRegister(instr->unclamped());
5193   Register result_reg = ToRegister(instr->result());
5194   __ ClampUint8(result_reg, unclamped_reg);
5195 }
5196
5197
5198 void LCodeGen::DoClampTToUint8(LClampTToUint8* instr) {
5199   Register scratch = scratch0();
5200   Register input_reg = ToRegister(instr->unclamped());
5201   Register result_reg = ToRegister(instr->result());
5202   DoubleRegister temp_reg = ToDoubleRegister(instr->temp());
5203   Label is_smi, done, heap_number;
5204
5205   // Both smi and heap number cases are handled.
5206   __ UntagAndJumpIfSmi(scratch, input_reg, &is_smi);
5207
5208   // Check for heap number
5209   __ lw(scratch, FieldMemOperand(input_reg, HeapObject::kMapOffset));
5210   __ Branch(&heap_number, eq, scratch, Operand(factory()->heap_number_map()));
5211
5212   // Check for undefined. Undefined is converted to zero for clamping
5213   // conversions.
5214   DeoptimizeIf(ne, instr->environment(), input_reg,
5215                Operand(factory()->undefined_value()));
5216   __ mov(result_reg, zero_reg);
5217   __ jmp(&done);
5218
5219   // Heap number
5220   __ bind(&heap_number);
5221   __ ldc1(double_scratch0(), FieldMemOperand(input_reg,
5222                                              HeapNumber::kValueOffset));
5223   __ ClampDoubleToUint8(result_reg, double_scratch0(), temp_reg);
5224   __ jmp(&done);
5225
5226   __ bind(&is_smi);
5227   __ ClampUint8(result_reg, scratch);
5228
5229   __ bind(&done);
5230 }
5231
5232
5233 void LCodeGen::DoDoubleBits(LDoubleBits* instr) {
5234   DoubleRegister value_reg = ToDoubleRegister(instr->value());
5235   Register result_reg = ToRegister(instr->result());
5236   if (instr->hydrogen()->bits() == HDoubleBits::HIGH) {
5237     __ FmoveHigh(result_reg, value_reg);
5238   } else {
5239     __ FmoveLow(result_reg, value_reg);
5240   }
5241 }
5242
5243
5244 void LCodeGen::DoConstructDouble(LConstructDouble* instr) {
5245   Register hi_reg = ToRegister(instr->hi());
5246   Register lo_reg = ToRegister(instr->lo());
5247   DoubleRegister result_reg = ToDoubleRegister(instr->result());
5248   __ Move(result_reg, lo_reg, hi_reg);
5249 }
5250
5251
5252 void LCodeGen::DoAllocate(LAllocate* instr) {
5253   class DeferredAllocate V8_FINAL : public LDeferredCode {
5254    public:
5255     DeferredAllocate(LCodeGen* codegen, LAllocate* instr)
5256         : LDeferredCode(codegen), instr_(instr) { }
5257     virtual void Generate() V8_OVERRIDE {
5258       codegen()->DoDeferredAllocate(instr_);
5259     }
5260     virtual LInstruction* instr() V8_OVERRIDE { return instr_; }
5261    private:
5262     LAllocate* instr_;
5263   };
5264
5265   DeferredAllocate* deferred =
5266       new(zone()) DeferredAllocate(this, instr);
5267
5268   Register result = ToRegister(instr->result());
5269   Register scratch = ToRegister(instr->temp1());
5270   Register scratch2 = ToRegister(instr->temp2());
5271
5272   // Allocate memory for the object.
5273   AllocationFlags flags = TAG_OBJECT;
5274   if (instr->hydrogen()->MustAllocateDoubleAligned()) {
5275     flags = static_cast<AllocationFlags>(flags | DOUBLE_ALIGNMENT);
5276   }
5277   if (instr->hydrogen()->IsOldPointerSpaceAllocation()) {
5278     ASSERT(!instr->hydrogen()->IsOldDataSpaceAllocation());
5279     ASSERT(!instr->hydrogen()->IsNewSpaceAllocation());
5280     flags = static_cast<AllocationFlags>(flags | PRETENURE_OLD_POINTER_SPACE);
5281   } else if (instr->hydrogen()->IsOldDataSpaceAllocation()) {
5282     ASSERT(!instr->hydrogen()->IsNewSpaceAllocation());
5283     flags = static_cast<AllocationFlags>(flags | PRETENURE_OLD_DATA_SPACE);
5284   }
5285   if (instr->size()->IsConstantOperand()) {
5286     int32_t size = ToInteger32(LConstantOperand::cast(instr->size()));
5287     if (size <= Page::kMaxRegularHeapObjectSize) {
5288       __ Allocate(size, result, scratch, scratch2, deferred->entry(), flags);
5289     } else {
5290       __ jmp(deferred->entry());
5291     }
5292   } else {
5293     Register size = ToRegister(instr->size());
5294     __ Allocate(size,
5295                 result,
5296                 scratch,
5297                 scratch2,
5298                 deferred->entry(),
5299                 flags);
5300   }
5301
5302   __ bind(deferred->exit());
5303
5304   if (instr->hydrogen()->MustPrefillWithFiller()) {
5305     if (instr->size()->IsConstantOperand()) {
5306       int32_t size = ToInteger32(LConstantOperand::cast(instr->size()));
5307       __ li(scratch, Operand(size));
5308     } else {
5309       scratch = ToRegister(instr->size());
5310     }
5311     __ Subu(scratch, scratch, Operand(kPointerSize));
5312     __ Subu(result, result, Operand(kHeapObjectTag));
5313     Label loop;
5314     __ bind(&loop);
5315     __ li(scratch2, Operand(isolate()->factory()->one_pointer_filler_map()));
5316     __ Addu(at, result, Operand(scratch));
5317     __ sw(scratch2, MemOperand(at));
5318     __ Subu(scratch, scratch, Operand(kPointerSize));
5319     __ Branch(&loop, ge, scratch, Operand(zero_reg));
5320     __ Addu(result, result, Operand(kHeapObjectTag));
5321   }
5322 }
5323
5324
5325 void LCodeGen::DoDeferredAllocate(LAllocate* instr) {
5326   Register result = ToRegister(instr->result());
5327
5328   // TODO(3095996): Get rid of this. For now, we need to make the
5329   // result register contain a valid pointer because it is already
5330   // contained in the register pointer map.
5331   __ mov(result, zero_reg);
5332
5333   PushSafepointRegistersScope scope(this, Safepoint::kWithRegisters);
5334   if (instr->size()->IsRegister()) {
5335     Register size = ToRegister(instr->size());
5336     ASSERT(!size.is(result));
5337     __ SmiTag(size);
5338     __ push(size);
5339   } else {
5340     int32_t size = ToInteger32(LConstantOperand::cast(instr->size()));
5341     if (size >= 0 && size <= Smi::kMaxValue) {
5342       __ Push(Smi::FromInt(size));
5343     } else {
5344       // We should never get here at runtime => abort
5345       __ stop("invalid allocation size");
5346       return;
5347     }
5348   }
5349
5350   int flags = AllocateDoubleAlignFlag::encode(
5351       instr->hydrogen()->MustAllocateDoubleAligned());
5352   if (instr->hydrogen()->IsOldPointerSpaceAllocation()) {
5353     ASSERT(!instr->hydrogen()->IsOldDataSpaceAllocation());
5354     ASSERT(!instr->hydrogen()->IsNewSpaceAllocation());
5355     flags = AllocateTargetSpace::update(flags, OLD_POINTER_SPACE);
5356   } else if (instr->hydrogen()->IsOldDataSpaceAllocation()) {
5357     ASSERT(!instr->hydrogen()->IsNewSpaceAllocation());
5358     flags = AllocateTargetSpace::update(flags, OLD_DATA_SPACE);
5359   } else {
5360     flags = AllocateTargetSpace::update(flags, NEW_SPACE);
5361   }
5362   __ Push(Smi::FromInt(flags));
5363
5364   CallRuntimeFromDeferred(
5365       Runtime::kHiddenAllocateInTargetSpace, 2, instr, instr->context());
5366   __ StoreToSafepointRegisterSlot(v0, result);
5367 }
5368
5369
5370 void LCodeGen::DoToFastProperties(LToFastProperties* instr) {
5371   ASSERT(ToRegister(instr->value()).is(a0));
5372   ASSERT(ToRegister(instr->result()).is(v0));
5373   __ push(a0);
5374   CallRuntime(Runtime::kToFastProperties, 1, instr);
5375 }
5376
5377
5378 void LCodeGen::DoRegExpLiteral(LRegExpLiteral* instr) {
5379   ASSERT(ToRegister(instr->context()).is(cp));
5380   Label materialized;
5381   // Registers will be used as follows:
5382   // t3 = literals array.
5383   // a1 = regexp literal.
5384   // a0 = regexp literal clone.
5385   // a2 and t0-t2 are used as temporaries.
5386   int literal_offset =
5387       FixedArray::OffsetOfElementAt(instr->hydrogen()->literal_index());
5388   __ li(t3, instr->hydrogen()->literals());
5389   __ lw(a1, FieldMemOperand(t3, literal_offset));
5390   __ LoadRoot(at, Heap::kUndefinedValueRootIndex);
5391   __ Branch(&materialized, ne, a1, Operand(at));
5392
5393   // Create regexp literal using runtime function
5394   // Result will be in v0.
5395   __ li(t2, Operand(Smi::FromInt(instr->hydrogen()->literal_index())));
5396   __ li(t1, Operand(instr->hydrogen()->pattern()));
5397   __ li(t0, Operand(instr->hydrogen()->flags()));
5398   __ Push(t3, t2, t1, t0);
5399   CallRuntime(Runtime::kHiddenMaterializeRegExpLiteral, 4, instr);
5400   __ mov(a1, v0);
5401
5402   __ bind(&materialized);
5403   int size = JSRegExp::kSize + JSRegExp::kInObjectFieldCount * kPointerSize;
5404   Label allocated, runtime_allocate;
5405
5406   __ Allocate(size, v0, a2, a3, &runtime_allocate, TAG_OBJECT);
5407   __ jmp(&allocated);
5408
5409   __ bind(&runtime_allocate);
5410   __ li(a0, Operand(Smi::FromInt(size)));
5411   __ Push(a1, a0);
5412   CallRuntime(Runtime::kHiddenAllocateInNewSpace, 1, instr);
5413   __ pop(a1);
5414
5415   __ bind(&allocated);
5416   // Copy the content into the newly allocated memory.
5417   // (Unroll copy loop once for better throughput).
5418   for (int i = 0; i < size - kPointerSize; i += 2 * kPointerSize) {
5419     __ lw(a3, FieldMemOperand(a1, i));
5420     __ lw(a2, FieldMemOperand(a1, i + kPointerSize));
5421     __ sw(a3, FieldMemOperand(v0, i));
5422     __ sw(a2, FieldMemOperand(v0, i + kPointerSize));
5423   }
5424   if ((size % (2 * kPointerSize)) != 0) {
5425     __ lw(a3, FieldMemOperand(a1, size - kPointerSize));
5426     __ sw(a3, FieldMemOperand(v0, size - kPointerSize));
5427   }
5428 }
5429
5430
5431 void LCodeGen::DoFunctionLiteral(LFunctionLiteral* instr) {
5432   ASSERT(ToRegister(instr->context()).is(cp));
5433   // Use the fast case closure allocation code that allocates in new
5434   // space for nested functions that don't need literals cloning.
5435   bool pretenure = instr->hydrogen()->pretenure();
5436   if (!pretenure && instr->hydrogen()->has_no_literals()) {
5437     FastNewClosureStub stub(isolate(),
5438                             instr->hydrogen()->strict_mode(),
5439                             instr->hydrogen()->is_generator());
5440     __ li(a2, Operand(instr->hydrogen()->shared_info()));
5441     CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr);
5442   } else {
5443     __ li(a2, Operand(instr->hydrogen()->shared_info()));
5444     __ li(a1, Operand(pretenure ? factory()->true_value()
5445                                 : factory()->false_value()));
5446     __ Push(cp, a2, a1);
5447     CallRuntime(Runtime::kHiddenNewClosure, 3, instr);
5448   }
5449 }
5450
5451
5452 void LCodeGen::DoTypeof(LTypeof* instr) {
5453   ASSERT(ToRegister(instr->result()).is(v0));
5454   Register input = ToRegister(instr->value());
5455   __ push(input);
5456   CallRuntime(Runtime::kTypeof, 1, instr);
5457 }
5458
5459
5460 void LCodeGen::DoTypeofIsAndBranch(LTypeofIsAndBranch* instr) {
5461   Register input = ToRegister(instr->value());
5462
5463   Register cmp1 = no_reg;
5464   Operand cmp2 = Operand(no_reg);
5465
5466   Condition final_branch_condition = EmitTypeofIs(instr->TrueLabel(chunk_),
5467                                                   instr->FalseLabel(chunk_),
5468                                                   input,
5469                                                   instr->type_literal(),
5470                                                   &cmp1,
5471                                                   &cmp2);
5472
5473   ASSERT(cmp1.is_valid());
5474   ASSERT(!cmp2.is_reg() || cmp2.rm().is_valid());
5475
5476   if (final_branch_condition != kNoCondition) {
5477     EmitBranch(instr, final_branch_condition, cmp1, cmp2);
5478   }
5479 }
5480
5481
5482 Condition LCodeGen::EmitTypeofIs(Label* true_label,
5483                                  Label* false_label,
5484                                  Register input,
5485                                  Handle<String> type_name,
5486                                  Register* cmp1,
5487                                  Operand* cmp2) {
5488   // This function utilizes the delay slot heavily. This is used to load
5489   // values that are always usable without depending on the type of the input
5490   // register.
5491   Condition final_branch_condition = kNoCondition;
5492   Register scratch = scratch0();
5493   Factory* factory = isolate()->factory();
5494   if (String::Equals(type_name, factory->number_string())) {
5495     __ JumpIfSmi(input, true_label);
5496     __ lw(input, FieldMemOperand(input, HeapObject::kMapOffset));
5497     __ LoadRoot(at, Heap::kHeapNumberMapRootIndex);
5498     *cmp1 = input;
5499     *cmp2 = Operand(at);
5500     final_branch_condition = eq;
5501
5502   } else if (String::Equals(type_name, factory->string_string())) {
5503     __ JumpIfSmi(input, false_label);
5504     __ GetObjectType(input, input, scratch);
5505     __ Branch(USE_DELAY_SLOT, false_label,
5506               ge, scratch, Operand(FIRST_NONSTRING_TYPE));
5507     // input is an object so we can load the BitFieldOffset even if we take the
5508     // other branch.
5509     __ lbu(at, FieldMemOperand(input, Map::kBitFieldOffset));
5510     __ And(at, at, 1 << Map::kIsUndetectable);
5511     *cmp1 = at;
5512     *cmp2 = Operand(zero_reg);
5513     final_branch_condition = eq;
5514
5515   } else if (String::Equals(type_name, factory->symbol_string())) {
5516     __ JumpIfSmi(input, false_label);
5517     __ GetObjectType(input, input, scratch);
5518     *cmp1 = scratch;
5519     *cmp2 = Operand(SYMBOL_TYPE);
5520     final_branch_condition = eq;
5521
5522   } else if (String::Equals(type_name, factory->boolean_string())) {
5523     __ LoadRoot(at, Heap::kTrueValueRootIndex);
5524     __ Branch(USE_DELAY_SLOT, true_label, eq, at, Operand(input));
5525     __ LoadRoot(at, Heap::kFalseValueRootIndex);
5526     *cmp1 = at;
5527     *cmp2 = Operand(input);
5528     final_branch_condition = eq;
5529
5530   } else if (FLAG_harmony_typeof &&
5531              String::Equals(type_name, factory->null_string())) {
5532     __ LoadRoot(at, Heap::kNullValueRootIndex);
5533     *cmp1 = at;
5534     *cmp2 = Operand(input);
5535     final_branch_condition = eq;
5536
5537   } else if (String::Equals(type_name, factory->undefined_string())) {
5538     __ LoadRoot(at, Heap::kUndefinedValueRootIndex);
5539     __ Branch(USE_DELAY_SLOT, true_label, eq, at, Operand(input));
5540     // The first instruction of JumpIfSmi is an And - it is safe in the delay
5541     // slot.
5542     __ JumpIfSmi(input, false_label);
5543     // Check for undetectable objects => true.
5544     __ lw(input, FieldMemOperand(input, HeapObject::kMapOffset));
5545     __ lbu(at, FieldMemOperand(input, Map::kBitFieldOffset));
5546     __ And(at, at, 1 << Map::kIsUndetectable);
5547     *cmp1 = at;
5548     *cmp2 = Operand(zero_reg);
5549     final_branch_condition = ne;
5550
5551   } else if (String::Equals(type_name, factory->function_string())) {
5552     STATIC_ASSERT(NUM_OF_CALLABLE_SPEC_OBJECT_TYPES == 2);
5553     __ JumpIfSmi(input, false_label);
5554     __ GetObjectType(input, scratch, input);
5555     __ Branch(true_label, eq, input, Operand(JS_FUNCTION_TYPE));
5556     *cmp1 = input;
5557     *cmp2 = Operand(JS_FUNCTION_PROXY_TYPE);
5558     final_branch_condition = eq;
5559
5560   } else if (String::Equals(type_name, factory->object_string())) {
5561     __ JumpIfSmi(input, false_label);
5562     if (!FLAG_harmony_typeof) {
5563       __ LoadRoot(at, Heap::kNullValueRootIndex);
5564       __ Branch(USE_DELAY_SLOT, true_label, eq, at, Operand(input));
5565     }
5566     Register map = input;
5567     __ GetObjectType(input, map, scratch);
5568     __ Branch(false_label,
5569               lt, scratch, Operand(FIRST_NONCALLABLE_SPEC_OBJECT_TYPE));
5570     __ Branch(USE_DELAY_SLOT, false_label,
5571               gt, scratch, Operand(LAST_NONCALLABLE_SPEC_OBJECT_TYPE));
5572     // map is still valid, so the BitField can be loaded in delay slot.
5573     // Check for undetectable objects => false.
5574     __ lbu(at, FieldMemOperand(map, Map::kBitFieldOffset));
5575     __ And(at, at, 1 << Map::kIsUndetectable);
5576     *cmp1 = at;
5577     *cmp2 = Operand(zero_reg);
5578     final_branch_condition = eq;
5579
5580   } else {
5581     *cmp1 = at;
5582     *cmp2 = Operand(zero_reg);  // Set to valid regs, to avoid caller assertion.
5583     __ Branch(false_label);
5584   }
5585
5586   return final_branch_condition;
5587 }
5588
5589
5590 void LCodeGen::DoIsConstructCallAndBranch(LIsConstructCallAndBranch* instr) {
5591   Register temp1 = ToRegister(instr->temp());
5592
5593   EmitIsConstructCall(temp1, scratch0());
5594
5595   EmitBranch(instr, eq, temp1,
5596              Operand(Smi::FromInt(StackFrame::CONSTRUCT)));
5597 }
5598
5599
5600 void LCodeGen::EmitIsConstructCall(Register temp1, Register temp2) {
5601   ASSERT(!temp1.is(temp2));
5602   // Get the frame pointer for the calling frame.
5603   __ lw(temp1, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
5604
5605   // Skip the arguments adaptor frame if it exists.
5606   Label check_frame_marker;
5607   __ lw(temp2, MemOperand(temp1, StandardFrameConstants::kContextOffset));
5608   __ Branch(&check_frame_marker, ne, temp2,
5609             Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
5610   __ lw(temp1, MemOperand(temp1, StandardFrameConstants::kCallerFPOffset));
5611
5612   // Check the marker in the calling frame.
5613   __ bind(&check_frame_marker);
5614   __ lw(temp1, MemOperand(temp1, StandardFrameConstants::kMarkerOffset));
5615 }
5616
5617
5618 void LCodeGen::EnsureSpaceForLazyDeopt(int space_needed) {
5619   if (!info()->IsStub()) {
5620     // Ensure that we have enough space after the previous lazy-bailout
5621     // instruction for patching the code here.
5622     int current_pc = masm()->pc_offset();
5623     if (current_pc < last_lazy_deopt_pc_ + space_needed) {
5624       int padding_size = last_lazy_deopt_pc_ + space_needed - current_pc;
5625       ASSERT_EQ(0, padding_size % Assembler::kInstrSize);
5626       while (padding_size > 0) {
5627         __ nop();
5628         padding_size -= Assembler::kInstrSize;
5629       }
5630     }
5631   }
5632   last_lazy_deopt_pc_ = masm()->pc_offset();
5633 }
5634
5635
5636 void LCodeGen::DoLazyBailout(LLazyBailout* instr) {
5637   last_lazy_deopt_pc_ = masm()->pc_offset();
5638   ASSERT(instr->HasEnvironment());
5639   LEnvironment* env = instr->environment();
5640   RegisterEnvironmentForDeoptimization(env, Safepoint::kLazyDeopt);
5641   safepoints_.RecordLazyDeoptimizationIndex(env->deoptimization_index());
5642 }
5643
5644
5645 void LCodeGen::DoDeoptimize(LDeoptimize* instr) {
5646   Deoptimizer::BailoutType type = instr->hydrogen()->type();
5647   // TODO(danno): Stubs expect all deopts to be lazy for historical reasons (the
5648   // needed return address), even though the implementation of LAZY and EAGER is
5649   // now identical. When LAZY is eventually completely folded into EAGER, remove
5650   // the special case below.
5651   if (info()->IsStub() && type == Deoptimizer::EAGER) {
5652     type = Deoptimizer::LAZY;
5653   }
5654
5655   Comment(";;; deoptimize: %s", instr->hydrogen()->reason());
5656   DeoptimizeIf(al, instr->environment(), type, zero_reg, Operand(zero_reg));
5657 }
5658
5659
5660 void LCodeGen::DoDummy(LDummy* instr) {
5661   // Nothing to see here, move on!
5662 }
5663
5664
5665 void LCodeGen::DoDummyUse(LDummyUse* instr) {
5666   // Nothing to see here, move on!
5667 }
5668
5669
5670 void LCodeGen::DoDeferredStackCheck(LStackCheck* instr) {
5671   PushSafepointRegistersScope scope(this, Safepoint::kWithRegisters);
5672   LoadContextFromDeferred(instr->context());
5673   __ CallRuntimeSaveDoubles(Runtime::kHiddenStackGuard);
5674   RecordSafepointWithLazyDeopt(
5675       instr, RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS);
5676   ASSERT(instr->HasEnvironment());
5677   LEnvironment* env = instr->environment();
5678   safepoints_.RecordLazyDeoptimizationIndex(env->deoptimization_index());
5679 }
5680
5681
5682 void LCodeGen::DoStackCheck(LStackCheck* instr) {
5683   class DeferredStackCheck V8_FINAL : public LDeferredCode {
5684    public:
5685     DeferredStackCheck(LCodeGen* codegen, LStackCheck* instr)
5686         : LDeferredCode(codegen), instr_(instr) { }
5687     virtual void Generate() V8_OVERRIDE {
5688       codegen()->DoDeferredStackCheck(instr_);
5689     }
5690     virtual LInstruction* instr() V8_OVERRIDE { return instr_; }
5691    private:
5692     LStackCheck* instr_;
5693   };
5694
5695   ASSERT(instr->HasEnvironment());
5696   LEnvironment* env = instr->environment();
5697   // There is no LLazyBailout instruction for stack-checks. We have to
5698   // prepare for lazy deoptimization explicitly here.
5699   if (instr->hydrogen()->is_function_entry()) {
5700     // Perform stack overflow check.
5701     Label done;
5702     __ LoadRoot(at, Heap::kStackLimitRootIndex);
5703     __ Branch(&done, hs, sp, Operand(at));
5704     ASSERT(instr->context()->IsRegister());
5705     ASSERT(ToRegister(instr->context()).is(cp));
5706     CallCode(isolate()->builtins()->StackCheck(),
5707              RelocInfo::CODE_TARGET,
5708              instr);
5709     __ bind(&done);
5710   } else {
5711     ASSERT(instr->hydrogen()->is_backwards_branch());
5712     // Perform stack overflow check if this goto needs it before jumping.
5713     DeferredStackCheck* deferred_stack_check =
5714         new(zone()) DeferredStackCheck(this, instr);
5715     __ LoadRoot(at, Heap::kStackLimitRootIndex);
5716     __ Branch(deferred_stack_check->entry(), lo, sp, Operand(at));
5717     EnsureSpaceForLazyDeopt(Deoptimizer::patch_size());
5718     __ bind(instr->done_label());
5719     deferred_stack_check->SetExit(instr->done_label());
5720     RegisterEnvironmentForDeoptimization(env, Safepoint::kLazyDeopt);
5721     // Don't record a deoptimization index for the safepoint here.
5722     // This will be done explicitly when emitting call and the safepoint in
5723     // the deferred code.
5724   }
5725 }
5726
5727
5728 void LCodeGen::DoOsrEntry(LOsrEntry* instr) {
5729   // This is a pseudo-instruction that ensures that the environment here is
5730   // properly registered for deoptimization and records the assembler's PC
5731   // offset.
5732   LEnvironment* environment = instr->environment();
5733
5734   // If the environment were already registered, we would have no way of
5735   // backpatching it with the spill slot operands.
5736   ASSERT(!environment->HasBeenRegistered());
5737   RegisterEnvironmentForDeoptimization(environment, Safepoint::kNoLazyDeopt);
5738
5739   GenerateOsrPrologue();
5740 }
5741
5742
5743 void LCodeGen::DoForInPrepareMap(LForInPrepareMap* instr) {
5744   Register result = ToRegister(instr->result());
5745   Register object = ToRegister(instr->object());
5746   __ LoadRoot(at, Heap::kUndefinedValueRootIndex);
5747   DeoptimizeIf(eq, instr->environment(), object, Operand(at));
5748
5749   Register null_value = t1;
5750   __ LoadRoot(null_value, Heap::kNullValueRootIndex);
5751   DeoptimizeIf(eq, instr->environment(), object, Operand(null_value));
5752
5753   __ And(at, object, kSmiTagMask);
5754   DeoptimizeIf(eq, instr->environment(), at, Operand(zero_reg));
5755
5756   STATIC_ASSERT(FIRST_JS_PROXY_TYPE == FIRST_SPEC_OBJECT_TYPE);
5757   __ GetObjectType(object, a1, a1);
5758   DeoptimizeIf(le, instr->environment(), a1, Operand(LAST_JS_PROXY_TYPE));
5759
5760   Label use_cache, call_runtime;
5761   ASSERT(object.is(a0));
5762   __ CheckEnumCache(null_value, &call_runtime);
5763
5764   __ lw(result, FieldMemOperand(object, HeapObject::kMapOffset));
5765   __ Branch(&use_cache);
5766
5767   // Get the set of properties to enumerate.
5768   __ bind(&call_runtime);
5769   __ push(object);
5770   CallRuntime(Runtime::kGetPropertyNamesFast, 1, instr);
5771
5772   __ lw(a1, FieldMemOperand(v0, HeapObject::kMapOffset));
5773   ASSERT(result.is(v0));
5774   __ LoadRoot(at, Heap::kMetaMapRootIndex);
5775   DeoptimizeIf(ne, instr->environment(), a1, Operand(at));
5776   __ bind(&use_cache);
5777 }
5778
5779
5780 void LCodeGen::DoForInCacheArray(LForInCacheArray* instr) {
5781   Register map = ToRegister(instr->map());
5782   Register result = ToRegister(instr->result());
5783   Label load_cache, done;
5784   __ EnumLength(result, map);
5785   __ Branch(&load_cache, ne, result, Operand(Smi::FromInt(0)));
5786   __ li(result, Operand(isolate()->factory()->empty_fixed_array()));
5787   __ jmp(&done);
5788
5789   __ bind(&load_cache);
5790   __ LoadInstanceDescriptors(map, result);
5791   __ lw(result,
5792         FieldMemOperand(result, DescriptorArray::kEnumCacheOffset));
5793   __ lw(result,
5794         FieldMemOperand(result, FixedArray::SizeFor(instr->idx())));
5795   DeoptimizeIf(eq, instr->environment(), result, Operand(zero_reg));
5796
5797   __ bind(&done);
5798 }
5799
5800
5801 void LCodeGen::DoCheckMapValue(LCheckMapValue* instr) {
5802   Register object = ToRegister(instr->value());
5803   Register map = ToRegister(instr->map());
5804   __ lw(scratch0(), FieldMemOperand(object, HeapObject::kMapOffset));
5805   DeoptimizeIf(ne, instr->environment(), map, Operand(scratch0()));
5806 }
5807
5808
5809 void LCodeGen::DoDeferredLoadMutableDouble(LLoadFieldByIndex* instr,
5810                                            Register result,
5811                                            Register object,
5812                                            Register index) {
5813   PushSafepointRegistersScope scope(this, Safepoint::kWithRegisters);
5814   __ Push(object, index);
5815   __ mov(cp, zero_reg);
5816   __ CallRuntimeSaveDoubles(Runtime::kLoadMutableDouble);
5817   RecordSafepointWithRegisters(
5818      instr->pointer_map(), 2, Safepoint::kNoLazyDeopt);
5819   __ StoreToSafepointRegisterSlot(v0, result);
5820 }
5821
5822
5823 void LCodeGen::DoLoadFieldByIndex(LLoadFieldByIndex* instr) {
5824   class DeferredLoadMutableDouble V8_FINAL : public LDeferredCode {
5825    public:
5826     DeferredLoadMutableDouble(LCodeGen* codegen,
5827                               LLoadFieldByIndex* instr,
5828                               Register result,
5829                               Register object,
5830                               Register index)
5831         : LDeferredCode(codegen),
5832           instr_(instr),
5833           result_(result),
5834           object_(object),
5835           index_(index) {
5836     }
5837     virtual void Generate() V8_OVERRIDE {
5838       codegen()->DoDeferredLoadMutableDouble(instr_, result_, object_, index_);
5839     }
5840     virtual LInstruction* instr() V8_OVERRIDE { return instr_; }
5841    private:
5842     LLoadFieldByIndex* instr_;
5843     Register result_;
5844     Register object_;
5845     Register index_;
5846   };
5847
5848   Register object = ToRegister(instr->object());
5849   Register index = ToRegister(instr->index());
5850   Register result = ToRegister(instr->result());
5851   Register scratch = scratch0();
5852
5853   DeferredLoadMutableDouble* deferred;
5854   deferred = new(zone()) DeferredLoadMutableDouble(
5855       this, instr, result, object, index);
5856
5857   Label out_of_object, done;
5858
5859   __ And(scratch, index, Operand(Smi::FromInt(1)));
5860   __ Branch(deferred->entry(), ne, scratch, Operand(zero_reg));
5861   __ sra(index, index, 1);
5862
5863   __ Branch(USE_DELAY_SLOT, &out_of_object, lt, index, Operand(zero_reg));
5864   __ sll(scratch, index, kPointerSizeLog2 - kSmiTagSize);  // In delay slot.
5865
5866   STATIC_ASSERT(kPointerSizeLog2 > kSmiTagSize);
5867   __ Addu(scratch, object, scratch);
5868   __ lw(result, FieldMemOperand(scratch, JSObject::kHeaderSize));
5869
5870   __ Branch(&done);
5871
5872   __ bind(&out_of_object);
5873   __ lw(result, FieldMemOperand(object, JSObject::kPropertiesOffset));
5874   // Index is equal to negated out of object property index plus 1.
5875   __ Subu(scratch, result, scratch);
5876   __ lw(result, FieldMemOperand(scratch,
5877                                 FixedArray::kHeaderSize - kPointerSize));
5878   __ bind(deferred->exit());
5879   __ bind(&done);
5880 }
5881
5882
5883 void LCodeGen::DoStoreFrameContext(LStoreFrameContext* instr) {
5884   Register context = ToRegister(instr->context());
5885   __ sw(context, MemOperand(fp, StandardFrameConstants::kContextOffset));
5886 }
5887
5888
5889 void LCodeGen::DoAllocateBlockContext(LAllocateBlockContext* instr) {
5890   Handle<ScopeInfo> scope_info = instr->scope_info();
5891   __ li(at, scope_info);
5892   __ Push(at, ToRegister(instr->function()));
5893   CallRuntime(Runtime::kHiddenPushBlockContext, 2, instr);
5894   RecordSafepoint(Safepoint::kNoLazyDeopt);
5895 }
5896
5897
5898 #undef __
5899
5900 } }  // namespace v8::internal