A64: Todos - peek/poke and branch generator

src/a64/lithium-codegen-a64.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 178 matching lines @@
     __ Fcmp(scratch_, 0.0);
     __ B(le, label);
   }
 
  private:
   const FPRegister& value_;
   const FPRegister& scratch_;
 };
 
 
+// Test the input and branch if it is a heap number.
+class BranchIfHeapNumber : public BranchGenerator {
+ public:
+  BranchIfHeapNumber(LCodeGen* codegen, const Register& value)
+      : BranchGenerator(codegen), value_(value) { }
+
+  virtual void Emit(Label* label) const {
+    __ JumpIfHeapNumber(value_, label);
+  }
+
+  virtual void EmitInverted(Label* label) const {
+    __ JumpIfNotHeapNumber(value_, label);
+  }
+
+ private:
+  const Register& value_;
+};
+
+
 void LCodeGen::WriteTranslation(LEnvironment* environment,
                                 Translation* translation) {
   if (environment == NULL) return;
 
   // The translation includes one command per value in the environment.
   int translation_size = environment->translation_size();
   // The output frame height does not include the parameters.
   int height = translation_size - environment->parameter_count();
 
   WriteTranslation(environment->outer(), translation);
@@ skipping 387 matching lines @@
   }
 
   if (info()->saves_caller_doubles()) {
     Comment(";;; Save clobbered callee double registers");
     ASSERT(NeedsEagerFrame());
     BitVector* doubles = chunk()->allocated_double_registers();
     BitVector::Iterator iterator(doubles);
     int count = 0;
     while (!iterator.Done()) {
       FPRegister value = FPRegister::FromAllocationIndex(iterator.Current());
-      // TODO(jbramley): Make Poke support FPRegisters.
-      __ Str(value, MemOperand(__ StackPointer(), count * kDoubleSize));
+      __ Poke(value, count * kDoubleSize);
       iterator.Advance();
       count++;
     }
   }
 
   // Allocate a local context if needed.
   int heap_slots = info()->num_heap_slots() - Context::MIN_CONTEXT_SLOTS;
   if (heap_slots > 0) {
     Comment(";;; Allocate local context");
     // Argument to NewContext is the function, which is in x1.
@@ skipping 597 matching lines @@
 
 template<class InstrType>
 void LCodeGen::EmitBranchIfNonZeroNumber(InstrType instr,
                                          const FPRegister& value,
                                          const FPRegister& scratch) {
   BranchIfNonZeroNumber branch(this, value, scratch);
   EmitBranchGeneric(instr, branch);
 }
 
 
+template<class InstrType>
+void LCodeGen::EmitBranchIfHeapNumber(InstrType instr,
+                                      const Register& value) {
+  BranchIfHeapNumber branch(this, value);
+  EmitBranchGeneric(instr, branch);
+}
+
+
 void LCodeGen::DoGap(LGap* gap) {
   for (int i = LGap::FIRST_INNER_POSITION;
        i <= LGap::LAST_INNER_POSITION;
        i++) {
     LGap::InnerPosition inner_pos = static_cast<LGap::InnerPosition>(i);
     LParallelMove* move = gap->GetParallelMove(inner_pos);
     if (move != NULL) {
       resolver_.Resolve(move);
     }
   }
@@ skipping 1654 matching lines @@
   if (r.IsSmiOrInteger32() || r.IsDouble()) {
     __ B(instr->TrueLabel(chunk_));
   } else {
     ASSERT(r.IsTagged());
     Register value = ToRegister(instr->value());
     HType type = instr->hydrogen()->value()->type();
     if (type.IsTaggedNumber()) {
       __ B(instr->TrueLabel(chunk_));
     }
     __ JumpIfSmi(value, instr->TrueLabel(chunk_));
-    // TODO(jbramley): Add an EmitBranch helper for this.
-    __ JumpForHeapNumber(value, NoReg,
-                         instr->TrueLabel(chunk_), instr->FalseLabel(chunk_));
+
+    EmitBranchIfHeapNumber(instr, value);
   }
 }
 
 
 void LCodeGen::DoIsObjectAndBranch(LIsObjectAndBranch* instr) {
   Label* is_object = instr->TrueLabel(chunk_);
   Label* is_not_object = instr->FalseLabel(chunk_);
   Register value = ToRegister(instr->value());
   Register map = ToRegister(instr->temp1());
   Register scratch = ToRegister(instr->temp2());
@@ skipping 1477 matching lines @@
     __ CallRuntime(Runtime::kTraceExit, 1);
   }
 
   if (info()->saves_caller_doubles()) {
     ASSERT(NeedsEagerFrame());
     BitVector* doubles = chunk()->allocated_double_registers();
     BitVector::Iterator iterator(doubles);
     int count = 0;
     while (!iterator.Done()) {
       FPRegister value = FPRegister::FromAllocationIndex(iterator.Current());
-      // TODO(jbramley): Make Peek support FPRegisters.
-      __ Ldr(value, MemOperand(__ StackPointer(), count * kDoubleSize));
+      __ Peek(value, count * kDoubleSize);
       iterator.Advance();
       count++;
     }
   }
 
   int no_frame_start = -1;
   if (NeedsEagerFrame()) {
     Register stack_pointer = masm()->StackPointer();
     __ Mov(stack_pointer, fp);
     no_frame_start = masm_->pc_offset();
@@ skipping 1086 matching lines @@
   __ Bind(&out_of_object);
   __ Ldr(result, FieldMemOperand(object, JSObject::kPropertiesOffset));
   // Index is equal to negated out of object property index plus 1.
   __ Sub(result, result, Operand::UntagSmiAndScale(index, kPointerSizeLog2));
   __ Ldr(result, FieldMemOperand(result,
                                  FixedArray::kHeaderSize - kPointerSize));
   __ Bind(&done);
 }
 
 } }  // namespace v8::internal