Add Uint32 representation

runtime/vm/intermediate_language_arm.cc

 // 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/globals.h"  // Needed here to get TARGET_ARCH_ARM.
 #if defined(TARGET_ARCH_ARM)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/cpu.h"
@@ skipping 5907 matching lines @@
   if (!is_smi()) {
     summary->set_temp(0, Location::RequiresRegister());
   }
   summary->set_out(0, Location::RequiresRegister());
   return summary;
 }
 
 
 class BoxIntegerSlowPath : public SlowPathCode {
  public:
-  explicit BoxIntegerSlowPath(BoxIntegerInstr* instruction)
+  explicit BoxIntegerSlowPath(Definition* instruction)
       : instruction_(instruction) { }
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
     __ Comment("BoxIntegerSlowPath");
     __ Bind(entry_label());
     Isolate* isolate = compiler->isolate();
     StubCode* stub_code = isolate->stub_code();
     const Class& mint_class =
         Class::ZoneHandle(isolate->object_store()->mint_class());
     const Code& stub =
         Code::Handle(isolate, stub_code->GetAllocationStubForClass(mint_class));
     const ExternalLabel label(stub.EntryPoint());
 
     LocationSummary* locs = instruction_->locs();
     ASSERT(!locs->live_registers()->Contains(locs->out(0)));
 
     compiler->SaveLiveRegisters(locs);
     compiler->GenerateCall(Scanner::kNoSourcePos,  // No token position.
                            &label,
                            RawPcDescriptors::kOther,
                            locs);
     __ mov(locs->out(0).reg(), Operand(R0));
     compiler->RestoreLiveRegisters(locs);
 
     __ b(exit_label());
   }
 
  private:
-  BoxIntegerInstr* instruction_;
+  Definition* instruction_;
 };
 
 
 void BoxIntegerInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (is_smi()) {
     PairLocation* value_pair = locs()->in(0).AsPairLocation();
     Register value_lo = value_pair->At(0).reg();
     Register out_reg = locs()->out(0).reg();
     __ mov(out_reg, Operand(value_lo));
     __ SmiTag(out_reg);
@@ skipping 256 matching lines @@
     deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptUnaryMintOp);
   }
   __ mvn(out_lo, Operand(left_lo));
   __ mvn(out_hi, Operand(left_hi));
   if (FLAG_throw_on_javascript_int_overflow) {
     EmitJavascriptIntOverflowCheck(compiler, deopt, out_lo, out_hi);
   }
 }
 
 
+CompileType BinaryUint32OpInstr::ComputeType() const {
+  return CompileType::Int();
+}
+
+
+CompileType ShiftUint32OpInstr::ComputeType() const {
+  return CompileType::Int();
+}
+
+
+CompileType UnaryUint32OpInstr::ComputeType() const {
+  return CompileType::Int();
+}
+
+
+CompileType BoxUint32Instr::ComputeType() const {
+  return CompileType::Int();
+}
+
+
+CompileType UnboxUint32Instr::ComputeType() const {
+  return CompileType::Int();
+}
+
+
+LocationSummary* BinaryUint32OpInstr::MakeLocationSummary(Isolate* isolate,
+                                                          bool opt) const {
+  const intptr_t kNumInputs = 2;
+  const intptr_t kNumTemps = 0;
+  LocationSummary* summary = new(isolate) LocationSummary(
+      isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
+  summary->set_in(0, Location::RequiresRegister());
+  summary->set_in(1, Location::RequiresRegister());
+  summary->set_out(0, Location::RequiresRegister());
+  return summary;
+}
+
+
+void BinaryUint32OpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  Register left = locs()->in(0).reg();
+  Register right = locs()->in(1).reg();
+  Register out = locs()->out(0).reg();
+  ASSERT(out != left);
+  switch (op_kind()) {
+    case Token::kBIT_AND:
+      __ and_(out, left, Operand(right));
+    break;
+    case Token::kBIT_OR:
+      __ orr(out, left, Operand(right));
+    break;
+    case Token::kBIT_XOR:
+      __ eor(out, left, Operand(right));
+    break;
+    case Token::kADD:
+      __ add(out, left, Operand(right));
+    break;
+    case Token::kSUB:
+      __ sub(out, left, Operand(right));
+    break;
+    default:
+      UNREACHABLE();
+  }
+}
+
+
+LocationSummary* ShiftUint32OpInstr::MakeLocationSummary(Isolate* isolate,
+                                                         bool opt) const {
+  const intptr_t kNumInputs = 2;
+  const intptr_t kNumTemps = 1;
+  LocationSummary* summary = new(isolate) LocationSummary(
+      isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
+  summary->set_in(0, Location::RequiresRegister());
+  summary->set_in(1, Location::RegisterOrSmiConstant(right()));
+  summary->set_temp(0, Location::RequiresRegister());
+  summary->set_out(0, Location::RequiresRegister());
+  return summary;
+}
+
+
+void ShiftUint32OpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  const intptr_t kShifterLimit = 31;
+
+  Register left = locs()->in(0).reg();
+  Register out = locs()->out(0).reg();
+  Register temp = locs()->temp(0).reg();
+
+  ASSERT(left != out);
+
+  Label* deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptShiftMintOp);
+
+  if (locs()->in(1).IsConstant()) {
+    // Shifter is constant.
+
+    const Object& constant = locs()->in(1).constant();
+    ASSERT(constant.IsSmi());
+    const intptr_t shift_value = Smi::Cast(constant).Value();
+
+    // Check constant shift value.
+    if (shift_value == 0) {
+      // Nothing to do.
+    } else if (shift_value < 0) {
+      // Invalid shift value.
+      __ b(deopt);
+    } else if (shift_value > kShifterLimit) {
+      // Result is 0.
+      __ eor(out, out, Operand(out));
+    } else {
+      // Do the shift: (shift_value > 0) && (shift_value <= kShifterLimit).
+      switch (op_kind()) {
+        case Token::kSHR:
+          __ Lsr(out, left, shift_value);
+        break;
+        case Token::kSHL:
+          __ Lsl(out, left, shift_value);
+        break;
+        default:
+          UNREACHABLE();
+      }
+    }
+    return;
+  }
+
+  // Non constant shift value.
+
+  Register shifter = locs()->in(1).reg();
+
+  Label done;
+  Label zero;
+
+  __ mov(temp, Operand(shifter));
+  __ SmiUntag(temp);
+  __ CompareImmediate(temp, 0);
+  // If shift value is < 0, deoptimize.
+  __ b(deopt, LT);
+  __ CompareImmediate(temp, kShifterLimit);
+  // If shift value is >= 32, return zero.
+  __ b(&zero, HI);
+
+  // Do the shift.
+  switch (op_kind()) {
+    case Token::kSHR:
+      __ Lsr(out, left, temp);
+      __ b(&done);
+    break;
+    case Token::kSHL:
+      __ Lsl(out, left, temp);
+      __ b(&done);
+    break;
+    default:
+      UNREACHABLE();
+  }
+
+  __ Bind(&zero);
+  // Shift was greater than 31 bits, just return zero.
+  __ eor(out, out, Operand(out));
+
+  // Exit path.
+  __ Bind(&done);
+}
+
+
+LocationSummary* UnaryUint32OpInstr::MakeLocationSummary(Isolate* isolate,
+                                                         bool opt) const {
+  const intptr_t kNumInputs = 1;
+  const intptr_t kNumTemps = 0;
+  LocationSummary* summary = new(isolate) LocationSummary(
+      isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
+  summary->set_in(0, Location::RequiresRegister());
+  summary->set_out(0, Location::RequiresRegister());
+  return summary;
+}
+
+
+void UnaryUint32OpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  Register left = locs()->in(0).reg();
+  Register out = locs()->out(0).reg();
+  ASSERT(left != out);
+
+  ASSERT(op_kind() == Token::kBIT_NOT);
+
+  __ mvn(out, Operand(left));
+}
+
+
+LocationSummary* BoxUint32Instr::MakeLocationSummary(Isolate* isolate,
+                                                     bool opt) const {
+  const intptr_t kNumInputs = 1;
+  const intptr_t kNumTemps = 1;
+  LocationSummary* summary = new(isolate) LocationSummary(
+      isolate, kNumInputs, kNumTemps, LocationSummary::kCallOnSlowPath);
+  summary->set_in(0, Location::RequiresRegister());
+  summary->set_temp(0, Location::RequiresRegister());
+  summary->set_out(0, Location::RequiresRegister());
+  return summary;
+}
+
+
+void BoxUint32Instr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  BoxIntegerSlowPath* slow_path = new BoxIntegerSlowPath(this);
+  compiler->AddSlowPathCode(slow_path);
+  Register value = locs()->in(0).reg();
+  Register out = locs()->out(0).reg();
+  Register temp = locs()->temp(0).reg();
+  ASSERT(value != out);
+
+  Label not_smi, done;
+
+  // TODO(johnmccutchan): Use range information to fast path smi / mint boxing.
+
+  // Test if this value is <= kSmiMax.
+  __ CompareImmediate(value, kSmiMax);
+  __ b(&not_smi, HI);
+  // Smi.
+  __ mov(out, Operand(value));
+  __ SmiTag(out);
+  __ b(&done);
+  __ Bind(&not_smi);
+  // Allocate a mint.
+  __ TryAllocate(
+    Class::ZoneHandle(Isolate::Current()->object_store()->mint_class()),
+      slow_path->entry_label(),
+      out,
+      temp);
+  __ Bind(slow_path->exit_label());
+  // Copy low word into mint.
+  __ StoreToOffset(kWord,
+                   value,
+                   out,
+                   Mint::value_offset() - kHeapObjectTag);
+  // Zero high word.
+  __ eor(temp, temp, Operand(temp));
+  __ StoreToOffset(kWord,
+                   temp,
+                   out,
+                   Mint::value_offset() - kHeapObjectTag + kWordSize);
+  __ Bind(&done);
+}
+
+
+
+LocationSummary* UnboxUint32Instr::MakeLocationSummary(Isolate* isolate,
+                                                       bool opt) const {
+  const intptr_t value_cid = value()->Type()->ToCid();
+  const intptr_t kNumInputs = 1;
+  const intptr_t kNumTemps =
+      ((value_cid == kMintCid) || (value_cid == kSmiCid)) ? 0 : 1;
+  LocationSummary* summary = new(isolate) LocationSummary(
+      isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
+  summary->set_in(0, Location::RequiresRegister());
+  if (kNumTemps > 0) {
+    summary->set_temp(0, Location::RequiresRegister());
+  }
+  summary->set_out(0, Location::RequiresRegister());
+  return summary;
+}
+
+
+void UnboxUint32Instr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  const intptr_t value_cid = value()->Type()->ToCid();
+  const Register value = locs()->in(0).reg();
+  const Register out = locs()->out(0).reg();
+  ASSERT(value != out);
+
+  // TODO(johnmccutchan): Emit better code for constant inputs.
+  if (value_cid == kMintCid) {
+    __ LoadFromOffset(kWord, out, value, Mint::value_offset() - kHeapObjectTag);
+  } else if (value_cid == kSmiCid) {
+    __ mov(out, Operand(value));
+    __ SmiUntag(out);
+  } else {
+    Register temp = locs()->temp(0).reg();
+    Label* deopt = compiler->AddDeoptStub(deopt_id_,
+                                          ICData::kDeoptUnboxInteger);
+    Label is_smi, done;
+    __ tst(value, Operand(kSmiTagMask));
+    __ b(&is_smi, EQ);
+    __ CompareClassId(value, kMintCid, temp);
+    __ b(deopt, NE);
+    __ LoadFromOffset(kWord, out, value, Mint::value_offset() - kHeapObjectTag);
+    __ b(&done);
+    __ Bind(&is_smi);
+    __ mov(out, Operand(value));
+    __ SmiUntag(out);
+    __ Bind(&done);
+  }
+}
+
+
+LocationSummary* UnboxedIntConverterInstr::MakeLocationSummary(Isolate* isolate,
+                                                               bool opt) const {
+  const intptr_t kNumInputs = 1;
+  const intptr_t kNumTemps = 0;
+  LocationSummary* summary = new(isolate) LocationSummary(
+      isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
+  if (from() == kUnboxedMint) {
+    summary->set_in(0, Location::Pair(Location::RequiresRegister(),
+                                      Location::RequiresRegister()));
+    summary->set_out(0, Location::RequiresRegister());
+  } else {
+    ASSERT(from() == kUnboxedUint32);
+    summary->set_in(0, Location::RequiresRegister());
+    summary->set_out(0, Location::Pair(Location::RequiresRegister(),
+                                       Location::RequiresRegister()));
+  }
+  return summary;
+}
+
+
+void UnboxedIntConverterInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  if (from() == kUnboxedMint) {
+    PairLocation* in_pair = locs()->in(0).AsPairLocation();
+    Register in_lo = in_pair->At(0).reg();
+    Register out = locs()->out(0).reg();
+    // Copy low word.
+    __ mov(out, Operand(in_lo));
+  } else {
+    ASSERT(from() == kUnboxedUint32);
+    Register in = locs()->in(0).reg();
+    PairLocation* out_pair = locs()->out(0).AsPairLocation();
+    Register out_lo = out_pair->At(0).reg();
+    Register out_hi = out_pair->At(1).reg();
+    // Copy low word.
+    __ mov(out_lo, Operand(in));
+    // Zero upper word.
+    __ eor(out_hi, out_hi, Operand(out_hi));
+  }
+}
+
+
 LocationSummary* ThrowInstr::MakeLocationSummary(Isolate* isolate,
                                                  bool opt) const {
   return new(isolate) LocationSummary(isolate, 0, 0, LocationSummary::kCall);
 }
 
 
 void ThrowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   compiler->GenerateRuntimeCall(token_pos(),
                                 deopt_id(),
                                 kThrowRuntimeEntry,
@@ skipping 215 matching lines @@
   compiler->GenerateCall(token_pos(), &label, stub_kind_, locs());
 #if defined(DEBUG)
   __ LoadImmediate(R4, kInvalidObjectPointer);
   __ LoadImmediate(R5, kInvalidObjectPointer);
 #endif
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM