Fix vm code base so that it can be built for --arch=simarm (no snapshot yet).

runtime/vm/deopt_instructions.cc

-// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
+// Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/deopt_instructions.h"
 
 #include "vm/assembler_macros.h"
 #include "vm/code_patcher.h"
 #include "vm/intermediate_language.h"
 #include "vm/locations.h"
 #include "vm/parser.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, compress_deopt_info, true,
             "Compress the size of the deoptimization info for optimized code.");
 DECLARE_FLAG(bool, trace_deoptimization);
 
 DeoptimizationContext::DeoptimizationContext(intptr_t* to_frame_start,
                                              intptr_t to_frame_size,
                                              const Array& object_table,
                                              intptr_t num_args,
                                              DeoptReasonId deopt_reason)
     : object_table_(object_table),
       to_frame_(to_frame_start),
       to_frame_size_(to_frame_size),
       from_frame_(NULL),
       from_frame_size_(0),
       registers_copy_(NULL),
-      xmm_registers_copy_(NULL),
+      fpu_registers_copy_(NULL),
       num_args_(num_args),
       deopt_reason_(deopt_reason),
       isolate_(Isolate::Current()) {
   from_frame_ = isolate_->deopt_frame_copy();
   from_frame_size_ = isolate_->deopt_frame_copy_size();
   registers_copy_ = isolate_->deopt_cpu_registers_copy();
-  xmm_registers_copy_ = isolate_->deopt_xmm_registers_copy();
+  fpu_registers_copy_ = isolate_->deopt_fpu_registers_copy();
   caller_fp_ = GetFromFp();
 }
 
 
 intptr_t DeoptimizationContext::GetFromFp() const {
   return from_frame_[from_frame_size_ - 1 - num_args_ - 1];
 }
 
 
 intptr_t DeoptimizationContext::GetFromPc() const {
@@ skipping 299 matching lines @@
   }
 
  private:
   const Register reg_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptRegisterInstr);
 };
 
 
 // Deoptimization instruction moving an XMM register.
-class DeoptXmmRegisterInstr: public DeoptInstr {
+class DeoptFpuRegisterInstr: public DeoptInstr {
  public:
-  explicit DeoptXmmRegisterInstr(intptr_t reg_as_int)
-      : reg_(static_cast<XmmRegister>(reg_as_int)) {}
+  explicit DeoptFpuRegisterInstr(intptr_t reg_as_int)
+      : reg_(static_cast<FpuRegister>(reg_as_int)) {}
 
   virtual intptr_t from_index() const { return static_cast<intptr_t>(reg_); }
-  virtual DeoptInstr::Kind kind() const { return kXmmRegister; }
+  virtual DeoptInstr::Kind kind() const { return kFpuRegister; }
 
   virtual const char* ToCString() const {
-    return Assembler::XmmRegisterName(reg_);
+    return Assembler::FpuRegisterName(reg_);
   }
 
   void Execute(DeoptimizationContext* deopt_context, intptr_t to_index) {
-    double value = deopt_context->XmmRegisterValue(reg_);
+    double value = deopt_context->FpuRegisterValue(reg_);
     intptr_t* to_addr = deopt_context->GetToFrameAddressAt(to_index);
     *reinterpret_cast<RawSmi**>(to_addr) = Smi::New(0);
     Isolate::Current()->DeferDoubleMaterialization(
         value, reinterpret_cast<RawDouble**>(to_addr));
   }
 
  private:
-  const XmmRegister reg_;
+  const FpuRegister reg_;
 
-  DISALLOW_COPY_AND_ASSIGN(DeoptXmmRegisterInstr);
+  DISALLOW_COPY_AND_ASSIGN(DeoptFpuRegisterInstr);
 };
 
 
-class DeoptInt64XmmRegisterInstr: public DeoptInstr {
+class DeoptInt64FpuRegisterInstr: public DeoptInstr {
  public:
-  explicit DeoptInt64XmmRegisterInstr(intptr_t reg_as_int)
-      : reg_(static_cast<XmmRegister>(reg_as_int)) {}
+  explicit DeoptInt64FpuRegisterInstr(intptr_t reg_as_int)
+      : reg_(static_cast<FpuRegister>(reg_as_int)) {}
 
   virtual intptr_t from_index() const { return static_cast<intptr_t>(reg_); }
-  virtual DeoptInstr::Kind kind() const { return kInt64XmmRegister; }
+  virtual DeoptInstr::Kind kind() const { return kInt64FpuRegister; }
 
   virtual const char* ToCString() const {
     const char* format = "%s(m)";
     intptr_t len =
-        OS::SNPrint(NULL, 0, format, Assembler::XmmRegisterName(reg_));
+        OS::SNPrint(NULL, 0, format, Assembler::FpuRegisterName(reg_));
     char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
-    OS::SNPrint(chars, len + 1, format, Assembler::XmmRegisterName(reg_));
+    OS::SNPrint(chars, len + 1, format, Assembler::FpuRegisterName(reg_));
     return chars;
   }
 
   void Execute(DeoptimizationContext* deopt_context, intptr_t to_index) {
-    int64_t value = deopt_context->XmmRegisterValueAsInt64(reg_);
+    int64_t value = deopt_context->FpuRegisterValueAsInt64(reg_);
     intptr_t* to_addr = deopt_context->GetToFrameAddressAt(to_index);
     *reinterpret_cast<RawSmi**>(to_addr) = Smi::New(0);
     if (Smi::IsValid64(value)) {
       *to_addr = reinterpret_cast<intptr_t>(
           Smi::New(static_cast<intptr_t>(value)));
     } else {
       Isolate::Current()->DeferMintMaterialization(
           value, reinterpret_cast<RawMint**>(to_addr));
     }
   }
 
  private:
-  const XmmRegister reg_;
+  const FpuRegister reg_;
 
-  DISALLOW_COPY_AND_ASSIGN(DeoptInt64XmmRegisterInstr);
+  DISALLOW_COPY_AND_ASSIGN(DeoptInt64FpuRegisterInstr);
 };
 
 
 // Deoptimization instruction creating a PC marker for the code of
 // function at 'object_table_index'.
 class DeoptPcMarkerInstr : public DeoptInstr {
  public:
   explicit DeoptPcMarkerInstr(intptr_t object_table_index)
       : object_table_index_(object_table_index) {
     ASSERT(object_table_index >= 0);
@@ skipping 167 matching lines @@
 DeoptInstr* DeoptInstr::Create(intptr_t kind_as_int, intptr_t from_index) {
   Kind kind = static_cast<Kind>(kind_as_int);
   switch (kind) {
     case kStackSlot: return new DeoptStackSlotInstr(from_index);
     case kDoubleStackSlot: return new DeoptDoubleStackSlotInstr(from_index);
     case kInt64StackSlot: return new DeoptInt64StackSlotInstr(from_index);
     case kRetAfterAddress: return new DeoptRetAfterAddressInstr(from_index);
     case kRetBeforeAddress: return new DeoptRetBeforeAddressInstr(from_index);
     case kConstant: return new DeoptConstantInstr(from_index);
     case kRegister: return new DeoptRegisterInstr(from_index);
-    case kXmmRegister: return new DeoptXmmRegisterInstr(from_index);
-    case kInt64XmmRegister: return new DeoptInt64XmmRegisterInstr(from_index);
+    case kFpuRegister: return new DeoptFpuRegisterInstr(from_index);
+    case kInt64FpuRegister: return new DeoptInt64FpuRegisterInstr(from_index);
     case kPcMarker: return new DeoptPcMarkerInstr(from_index);
     case kCallerFp: return new DeoptCallerFpInstr();
     case kCallerPc: return new DeoptCallerPcInstr();
     case kSuffix: return new DeoptSuffixInstr(from_index);
   }
   UNREACHABLE();
   return NULL;
 }
 
 
@@ skipping 82 matching lines @@
 
 void DeoptInfoBuilder::AddCopy(const Location& from_loc,
                                const Value& from_value,
                                const intptr_t to_index) {
   DeoptInstr* deopt_instr = NULL;
   if (from_loc.IsConstant()) {
     intptr_t object_table_index = FindOrAddObjectInTable(from_loc.constant());
     deopt_instr = new DeoptConstantInstr(object_table_index);
   } else if (from_loc.IsRegister()) {
     deopt_instr = new DeoptRegisterInstr(from_loc.reg());
-  } else if (from_loc.IsXmmRegister()) {
+  } else if (from_loc.IsFpuRegister()) {
     if (from_loc.representation() == Location::kDouble) {
-      deopt_instr = new DeoptXmmRegisterInstr(from_loc.xmm_reg());
+      deopt_instr = new DeoptFpuRegisterInstr(from_loc.fpu_reg());
     } else {
       ASSERT(from_loc.representation() == Location::kMint);
-      deopt_instr = new DeoptInt64XmmRegisterInstr(from_loc.xmm_reg());
+      deopt_instr = new DeoptInt64FpuRegisterInstr(from_loc.fpu_reg());
     }
   } else if (from_loc.IsStackSlot()) {
     intptr_t from_index = (from_loc.stack_index() < 0) ?
         from_loc.stack_index() + num_args_ :
         from_loc.stack_index() + num_args_ -
             ParsedFunction::kFirstLocalSlotIndex + 1;
     deopt_instr = new DeoptStackSlotInstr(from_index);
   } else if (from_loc.IsDoubleStackSlot()) {
     intptr_t from_index = (from_loc.stack_index() < 0) ?
         from_loc.stack_index() + num_args_ :
@@ skipping 98 matching lines @@
                           Smi* offset,
                           DeoptInfo* info,
                           Smi* reason) {
   intptr_t i = index * kEntrySize;
   *offset ^= table.At(i);
   *info ^= table.At(i + 1);
   *reason ^= table.At(i + 2);
 }
 
 }  // namespace dart