A64: Implement LCodeGen::GenerateDeoptJumpTable

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 814 matching lines @@
   // Force constant pool emission at the end of the deferred code to make
   // sure that no constant pools are emitted after deferred code because
   // deferred code generation is the last step which generates code. The two
   // following steps will only output data used by crakshaft.
   masm()->CheckConstPool(true, false);
 
   return !is_aborted();
 }
 
 
 bool LCodeGen::GenerateDeoptJumpTable() {

[jochen (gone - plz use gerrit), 2014/02/05 08:57:38]

ARM has a check that the table is not too far away. I didn't put the check here,
because eventually, we'll support arbitrary long jumps, right?

[Rodolph Perfetta (ARM), 2014/02/05 10:52:43]

Right, but in the mean time a debug check may save us some time when
investigating bugs.

On 2014/02/05 08:57:38, jochen wrote:

-  TODO_UNIMPLEMENTED("generate level 1 deopt table");
+  if (deopt_jump_table_.length() > 0) {
+    Comment(";;; -------------------- Jump table --------------------");
+  }
+  Label table_start;
+  __ bind(&table_start);

[ulan, 2014/02/05 10:25:41]

Use Bind instead.

+  Label needs_frame;
+  for (int i = 0; i < deopt_jump_table_.length(); i++) {
+    __ Bind(&deopt_jump_table_[i].label);
+    Address entry = deopt_jump_table_[i].address;
+    Deoptimizer::BailoutType type = deopt_jump_table_[i].bailout_type;
+    int id = Deoptimizer::GetDeoptimizationId(isolate(), entry, type);
+    if (id == Deoptimizer::kNotDeoptimizationEntry) {
+      Comment(";;; jump table entry %d.", i);
+    } else {
+      Comment(";;; jump table entry %d: deoptimization bailout %d.", i, id);
+    }
+    if (deopt_jump_table_[i].needs_frame) {
+      __ Mov(__ Tmp0(), Operand(ExternalReference::ForDeoptEntry(entry)));

[ulan, 2014/02/05 10:25:41]

I am not sure that we can use Tmp0, Tmp1 here. Rodolph, when is it safe to use
these registers?

[jochen (gone - plz use gerrit), 2014/02/05 10:34:17]

Tmp1() was uses in the old code (see line 1009) so I assumed it's safe.

[Rodolph Perfetta (ARM), 2014/02/05 10:52:43]

In Theory it is never safe to use them outside the macro assembler. It just so
happen that instruction used here don't need tmps at all. We'll revisit their
uses later but in the mean time asserting the code sequence in the else clause
below has a fixed length (therefore doesn't use tmps) would be good. 

On 2014/02/05 10:34:17, jochen wrote:

+      if (needs_frame.is_bound()) {
+        __ B(&needs_frame);
+      } else {
+        __ Bind(&needs_frame);
+        // This variant of deopt can only be used with stubs. Since we don't
+        // have a function pointer to install in the stack frame that we're
+        // building, install a special marker there instead.
+        ASSERT(info()->IsStub());
+        __ Mov(__ Tmp1(), Operand(Smi::FromInt(StackFrame::STUB)));
+        __ Push(lr, fp, cp, __ Tmp1());
+        __ Add(fp, __ StackPointer(), 2 * kPointerSize);
+        __ Call(__ Tmp0());
+      }
+    } else {
+      __ Call(entry, RelocInfo::RUNTIME_ENTRY);
+    }
+    masm()->CheckConstPool(false, false);
+  }
 
-  // TODO(jbramley): On ARM, the deopt entry for stubs is different in that it
-  // inserts a special marker instead of a function pointer. We need to do that
-  // same on A64, but since we don't use the jump table, we have to do it
-  // in LCodeGen::Deoptimize().
+  // Force constant pool emission at the end of the deopt jump table to make
+  // sure that no constant pools are emitted after.
+  masm()->CheckConstPool(true, false);
 
   // The deoptimization jump table is the last part of the instruction
   // sequence. Mark the generated code as done unless we bailed out.
   if (!is_aborted()) status_ = DONE;
   return !is_aborted();
 }
 
 
 bool LCodeGen::GenerateSafepointTable() {
   ASSERT(is_done());
@@ skipping 136 matching lines @@
     ASSERT(frame_is_built_);
     __ Call(entry, RelocInfo::RUNTIME_ENTRY);
     return;
   }
 
   if (info()->ShouldTrapOnDeopt()) {
     __ Debug("trap_on_deopt", __LINE__, BREAK);
   }
 
 
-  // TODO(all): Currently this code directly jump to the second level deopt
-  // table entry. This code need to be updated if we decide to use the
-  // 2 levels of table.
   ASSERT(info()->IsStub() || frame_is_built_);
   if (frame_is_built_) {
     __ Call(entry, RelocInfo::RUNTIME_ENTRY);
   } else {
-    // We need to build a frame to deoptimize a stub. Because stubs don't have a
-    // function pointer to put in the frame, put a special marker there instead.
-    // TODO(jbramley): In other architectures, this happens in the jump table.
-    // This is a temporary hack until we implement jump tables in A64.
-    __ Mov(__ Tmp1(), Operand(Smi::FromInt(StackFrame::STUB)));
-    __ Push(lr, fp, cp, __ Tmp1());
-    __ Add(fp, __ StackPointer(), 2 * kPointerSize);
-    // TODO(jbramley): Can this be a jump, rather than a call?
-    __ Call(entry, RelocInfo::RUNTIME_ENTRY);
+    // We often have several deopts to the same entry, reuse the last
+    // jump entry if this is the case.
+    if (deopt_jump_table_.is_empty() ||
+        (deopt_jump_table_.last().address != entry) ||
+        (deopt_jump_table_.last().bailout_type != bailout_type) ||
+        (deopt_jump_table_.last().needs_frame != !frame_is_built_)) {
+      Deoptimizer::JumpTableEntry table_entry(entry,
+                                              bailout_type,
+                                              !frame_is_built_);
+      deopt_jump_table_.Add(table_entry, zone());
+    }
+    __ B(&deopt_jump_table_.last().label);
   }
 }
 
 
 void LCodeGen::Deoptimize(LEnvironment* environment) {
   Deoptimizer::BailoutType bailout_type = info()->IsStub() ? Deoptimizer::LAZY
                                                            : Deoptimizer::EAGER;
   Deoptimize(environment, bailout_type);
 }
 
@@ skipping 4573 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