A64: Implement LOsrEntry and LUnknownOSRValue

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 1905 matching lines @@
                                    TranscendentalCacheStub::TAGGED);
       CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
       break;
     }
     default:
       UNREACHABLE();
   }
 }
 
 
+void LCodeGen::DoUnknownOSRValue(LUnknownOSRValue* instr) {
+  // Record the address of the first unknown OSR value as the place to enter.
+  if (osr_pc_offset_ == -1) osr_pc_offset_ = masm()->pc_offset();

[titzer, 2014/01/24 17:04:32]

You should have a subroutine like DoGenerateOsrPrologue() that roughly defines a
new prologue for the function; see the arm port for reference.

Basically, this prologue must set up the frame, because the builtin will jump
directly into the middle of this code from the unoptimized code.

+}
+
+
 void LCodeGen::DoCheckMaps(LCheckMaps* instr) {
   Register object = ToRegister(instr->value());
   Register map_reg = ToRegister(instr->temp());
 
   Label success;
   SmallMapList* map_set = instr->hydrogen()->map_set();
   __ Ldr(map_reg, FieldMemOperand(object, HeapObject::kMapOffset));
   for (int i = 0; i < map_set->length(); i++) {
     Handle<Map> map = map_set->at(i);
     __ CompareMap(map_reg, map, &success);
@@ skipping 2377 matching lines @@
 
   // Smi to double register conversion.
   __ Bind(&load_smi);
   __ SmiUntagToDouble(result, input);
 
   __ Bind(&done);
 }
 
 
 void LCodeGen::DoOsrEntry(LOsrEntry* instr) {
-  ASM_UNIMPLEMENTED_BREAK("DoOsrEntry");
+  // This is a pseudo-instruction that ensures that the environment here is
+  // properly registered for deoptimization and records the assembler's PC
+  // offset.
+  LEnvironment* environment = instr->environment();
+
+  // If the environment were already registered, we would have no way of
+  // backpatching it with the spill slot operands.
+  ASSERT(!environment->HasBeenRegistered());
+  RegisterEnvironmentForDeoptimization(environment, Safepoint::kNoLazyDeopt);
+
+  // Normally we record the first unknown OSR value as the entrypoint to the OSR
+  // code, but if there were none, record the entrypoint here.
+  if (osr_pc_offset_ == -1) osr_pc_offset_ = masm()->pc_offset();
 }
 
 
 void LCodeGen::DoOuterContext(LOuterContext* instr) {
   Register context = ToRegister(instr->context());
   Register result = ToRegister(instr->result());
   __ Ldr(result, ContextMemOperand(context, Context::PREVIOUS_INDEX));
 }
 
 
@@ skipping 1107 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