Make writing of frame translation platform independent.

src/arm64/lithium-codegen-arm64.h

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_ARM64_LITHIUM_CODEGEN_ARM64_H_
 #define V8_ARM64_LITHIUM_CODEGEN_ARM64_H_
 
 #include "src/arm64/lithium-arm64.h"
 
 #include "src/arm64/lithium-gap-resolver-arm64.h"
@@ skipping 10 matching lines @@
 class LDeferredCode;
 class SafepointGenerator;
 class BranchGenerator;
 
 class LCodeGen: public LCodeGenBase {
  public:
   LCodeGen(LChunk* chunk, MacroAssembler* assembler, CompilationInfo* info)
       : LCodeGenBase(chunk, assembler, info),
         deoptimizations_(4, info->zone()),
         jump_table_(4, info->zone()),
-        deoptimization_literals_(8, info->zone()),
         inlined_function_count_(0),
         scope_(info->scope()),
         translations_(info->zone()),
         deferred_(8, info->zone()),
         osr_pc_offset_(-1),
         frame_is_built_(false),
         safepoints_(info->zone()),
         resolver_(this),
         expected_safepoint_kind_(Safepoint::kSimple) {
     PopulateDeoptimizationLiteralsWithInlinedFunctions();
@@ skipping 149 matching lines @@
 
   template <class T>
   void EmitVectorLoadICRegisters(T* instr);
 
   // Emits optimized code for %_IsString(x).  Preserves input register.
   // Returns the condition on which a final split to
   // true and false label should be made, to optimize fallthrough.
   Condition EmitIsString(Register input, Register temp1, Label* is_not_string,
                          SmiCheck check_needed);
 
-  int DefineDeoptimizationLiteral(Handle<Object> literal);
   void PopulateDeoptimizationData(Handle<Code> code);
   void PopulateDeoptimizationLiteralsWithInlinedFunctions();
 
   MemOperand BuildSeqStringOperand(Register string,
                                    Register temp,
                                    LOperand* index,
                                    String::Encoding encoding);
   void DeoptimizeBranch(LInstruction* instr,
                         Deoptimizer::DeoptReason deopt_reason,
                         BranchType branch_type, Register reg = NoReg,
@@ skipping 123 matching lines @@
   void RecordSafepointWithRegisters(LPointerMap* pointers,
                                     int arguments,
                                     Safepoint::DeoptMode mode);
   void RecordSafepointWithLazyDeopt(LInstruction* instr,
                                     SafepointMode safepoint_mode);
 
   void EnsureSpaceForLazyDeopt(int space_needed) override;
 
   ZoneList<LEnvironment*> deoptimizations_;
   ZoneList<Deoptimizer::JumpTableEntry*> jump_table_;
-  ZoneList<Handle<Object> > deoptimization_literals_;
   int inlined_function_count_;
   Scope* const scope_;
   TranslationBuffer translations_;
   ZoneList<LDeferredCode*> deferred_;
   int osr_pc_offset_;
   bool frame_is_built_;
 
   // Builder that keeps track of safepoints in the code. The table itself is
   // emitted at the end of the generated code.
   SafepointTableBuilder safepoints_;
@@ skipping 90 matching lines @@
 
  protected:
   MacroAssembler* masm() const { return codegen_->masm(); }
 
   LCodeGen* codegen_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_ARM64_LITHIUM_CODEGEN_ARM64_H_