[macro-assembler] Remove a bunch of unused functions.

src/x64/macro-assembler-x64.cc

 // Copyright 2012 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.
 
 #if V8_TARGET_ARCH_X64
 
 #include "src/base/bits.h"
 #include "src/base/division-by-constant.h"
 #include "src/base/utils/random-number-generator.h"
 #include "src/bootstrapper.h"
@@ skipping 294 matching lines @@
 
   // Clobber clobbered input registers when running with the debug-code flag
   // turned on to provoke errors.
   if (emit_debug_code()) {
     Move(value, kZapValue, Assembler::RelocInfoNone());
     Move(dst, kZapValue, Assembler::RelocInfoNone());
   }
 }
 
 
-void MacroAssembler::RecordWriteArray(
-    Register object,
-    Register value,
-    Register index,
-    SaveFPRegsMode save_fp,
-    RememberedSetAction remembered_set_action,
-    SmiCheck smi_check,
-    PointersToHereCheck pointers_to_here_check_for_value) {
-  // First, check if a write barrier is even needed. The tests below
-  // catch stores of Smis.
-  Label done;
-
-  // Skip barrier if writing a smi.
-  if (smi_check == INLINE_SMI_CHECK) {
-    JumpIfSmi(value, &done);
-  }
-
-  // Array access: calculate the destination address. Index is not a smi.
-  Register dst = index;
-  leap(dst, Operand(object, index, times_pointer_size,
-                   FixedArray::kHeaderSize - kHeapObjectTag));
-
-  RecordWrite(object, dst, value, save_fp, remembered_set_action,
-              OMIT_SMI_CHECK, pointers_to_here_check_for_value);
-
-  bind(&done);
-
-  // Clobber clobbered input registers when running with the debug-code flag
-  // turned on to provoke errors.
-  if (emit_debug_code()) {
-    Move(value, kZapValue, Assembler::RelocInfoNone());
-    Move(index, kZapValue, Assembler::RelocInfoNone());
-  }
-}
-
-
 void MacroAssembler::RecordWriteForMap(Register object,
                                        Register map,
                                        Register dst,
                                        SaveFPRegsMode fp_mode) {
   DCHECK(!object.is(kScratchRegister));
   DCHECK(!object.is(map));
   DCHECK(!object.is(dst));
   DCHECK(!map.is(dst));
   AssertNotSmi(object);
 
@@ skipping 210 matching lines @@
   Pop(js_function);
 
   bind(&done);
 }
 
 void MacroAssembler::Assert(Condition cc, BailoutReason reason) {
   if (emit_debug_code()) Check(cc, reason);
 }
 
 
-void MacroAssembler::AssertFastElements(Register elements) {
-  if (emit_debug_code()) {
-    Label ok;
-    CompareRoot(FieldOperand(elements, HeapObject::kMapOffset),
-                Heap::kFixedArrayMapRootIndex);
-    j(equal, &ok, Label::kNear);
-    CompareRoot(FieldOperand(elements, HeapObject::kMapOffset),
-                Heap::kFixedDoubleArrayMapRootIndex);
-    j(equal, &ok, Label::kNear);
-    CompareRoot(FieldOperand(elements, HeapObject::kMapOffset),
-                Heap::kFixedCOWArrayMapRootIndex);
-    j(equal, &ok, Label::kNear);
-    Abort(kJSObjectWithFastElementsMapHasSlowElements);
-    bind(&ok);
-  }
-}
-
-
 void MacroAssembler::Check(Condition cc, BailoutReason reason) {
   Label L;
   j(cc, &L, Label::kNear);
   Abort(reason);
   // Control will not return here.
   bind(&L);
 }
 
 
 void MacroAssembler::CheckStackAlignment() {
   int frame_alignment = base::OS::ActivationFrameAlignment();
   int frame_alignment_mask = frame_alignment - 1;
   if (frame_alignment > kPointerSize) {
     DCHECK(base::bits::IsPowerOfTwo32(frame_alignment));
     Label alignment_as_expected;
     testp(rsp, Immediate(frame_alignment_mask));
     j(zero, &alignment_as_expected, Label::kNear);
     // Abort if stack is not aligned.
     int3();
     bind(&alignment_as_expected);
   }
 }
 
 
-void MacroAssembler::NegativeZeroTest(Register result,
-                                      Register op,
-                                      Label* then_label) {
-  Label ok;
-  testl(result, result);
-  j(not_zero, &ok, Label::kNear);
-  testl(op, op);
-  j(sign, then_label);
-  bind(&ok);
-}
-
-
 void MacroAssembler::Abort(BailoutReason reason) {
 #ifdef DEBUG
   const char* msg = GetBailoutReason(reason);
   if (msg != NULL) {
     RecordComment("Abort message: ");
     RecordComment(msg);
   }
 
   if (FLAG_trap_on_abort) {
     int3();
@@ skipping 23 matching lines @@
   DCHECK(AllowThisStubCall(stub));  // Calls are not allowed in some stubs
   Call(stub->GetCode(), RelocInfo::CODE_TARGET, ast_id);
 }
 
 
 void MacroAssembler::TailCallStub(CodeStub* stub) {
   Jump(stub->GetCode(), RelocInfo::CODE_TARGET);
 }
 
 
-void MacroAssembler::StubReturn(int argc) {
-  DCHECK(argc >= 1 && generating_stub());
-  ret((argc - 1) * kPointerSize);
-}
-
-
 bool MacroAssembler::AllowThisStubCall(CodeStub* stub) {
   return has_frame_ || !stub->SometimesSetsUpAFrame();
 }
 
 void MacroAssembler::CallRuntime(const Runtime::Function* f,
                                  int num_arguments,
                                  SaveFPRegsMode save_doubles) {
   // If the expected number of arguments of the runtime function is
   // constant, we check that the actual number of arguments match the
   // expectation.
@@ skipping 649 matching lines @@
 
 
 void MacroAssembler::Cmp(const Operand& dst, Smi* src) {
   // The Operand cannot use the smi register.
   Register smi_reg = GetSmiConstant(src);
   DCHECK(!dst.AddressUsesRegister(smi_reg));
   cmpp(dst, smi_reg);
 }
 
 
-void MacroAssembler::SmiCompareInteger32(const Operand& dst, Register src) {
-  if (SmiValuesAre32Bits()) {
-    cmpl(Operand(dst, kSmiShift / kBitsPerByte), src);
-  } else {
-    DCHECK(SmiValuesAre31Bits());
-    SmiToInteger32(kScratchRegister, dst);
-    cmpl(kScratchRegister, src);
-  }
-}
-
-
 void MacroAssembler::PositiveSmiTimesPowerOfTwoToInteger64(Register dst,
                                                            Register src,
                                                            int power) {
   DCHECK(power >= 0);
   DCHECK(power < 64);
   if (power == 0) {
     SmiToInteger64(dst, src);
     return;
   }
   if (!dst.is(src)) {
     movp(dst, src);
   }
   if (power < kSmiShift) {
     sarp(dst, Immediate(kSmiShift - power));
   } else if (power > kSmiShift) {
     shlp(dst, Immediate(power - kSmiShift));
   }
 }
 
 
-void MacroAssembler::PositiveSmiDivPowerOfTwoToInteger32(Register dst,
-                                                         Register src,
-                                                         int power) {
-  DCHECK((0 <= power) && (power < 32));
-  if (dst.is(src)) {
-    shrp(dst, Immediate(power + kSmiShift));
-  } else {
-    UNIMPLEMENTED();  // Not used.
-  }
-}
-
-
-void MacroAssembler::SmiOrIfSmis(Register dst, Register src1, Register src2,
-                                 Label* on_not_smis,
-                                 Label::Distance near_jump) {
-  if (dst.is(src1) || dst.is(src2)) {
-    DCHECK(!src1.is(kScratchRegister));
-    DCHECK(!src2.is(kScratchRegister));
-    movp(kScratchRegister, src1);
-    orp(kScratchRegister, src2);
-    JumpIfNotSmi(kScratchRegister, on_not_smis, near_jump);
-    movp(dst, kScratchRegister);
-  } else {
-    movp(dst, src1);
-    orp(dst, src2);
-    JumpIfNotSmi(dst, on_not_smis, near_jump);
-  }
-}
-
-
 Condition MacroAssembler::CheckSmi(Register src) {
   STATIC_ASSERT(kSmiTag == 0);
   testb(src, Immediate(kSmiTagMask));
   return zero;
 }
 
 
 Condition MacroAssembler::CheckSmi(const Operand& src) {
   STATIC_ASSERT(kSmiTag == 0);
   testb(src, Immediate(kSmiTagMask));
@@ skipping 80 matching lines @@
     testl(src, src);
     return positive;
   } else {
     DCHECK(SmiValuesAre31Bits());
     testl(src, Immediate(0xc0000000));
     return zero;
   }
 }
 
 
-void MacroAssembler::CheckSmiToIndicator(Register dst, Register src) {
-  if (dst.is(src)) {
-    andl(dst, Immediate(kSmiTagMask));
-  } else {
-    movl(dst, Immediate(kSmiTagMask));
-    andl(dst, src);
-  }
-}
-
-
-void MacroAssembler::CheckSmiToIndicator(Register dst, const Operand& src) {
-  if (!(src.AddressUsesRegister(dst))) {
-    movl(dst, Immediate(kSmiTagMask));
-    andl(dst, src);
-  } else {
-    movl(dst, src);
-    andl(dst, Immediate(kSmiTagMask));
-  }
-}
-
-
 void MacroAssembler::JumpIfValidSmiValue(Register src,
                                          Label* on_valid,
                                          Label::Distance near_jump) {
   Condition is_valid = CheckInteger32ValidSmiValue(src);
   j(is_valid, on_valid, near_jump);
 }
 
 
 void MacroAssembler::JumpIfNotValidSmiValue(Register src,
                                             Label* on_invalid,
@@ skipping 1502 matching lines @@
 }
 
 
 void MacroAssembler::MoveHeapObject(Register result,
                                     Handle<Object> object) {
   DCHECK(object->IsHeapObject());
   Move(result, object, RelocInfo::EMBEDDED_OBJECT);
 }
 
 
-void MacroAssembler::LoadGlobalCell(Register dst, Handle<Cell> cell) {
-  if (dst.is(rax)) {
-    AllowDeferredHandleDereference embedding_raw_address;
-    load_rax(cell.location(), RelocInfo::CELL);
-  } else {
-    Move(dst, cell, RelocInfo::CELL);
-    movp(dst, Operand(dst, 0));
-  }
-}
-
-
-void MacroAssembler::CmpWeakValue(Register value, Handle<WeakCell> cell,
-                                  Register scratch) {
-  Move(scratch, cell, RelocInfo::EMBEDDED_OBJECT);
-  cmpp(value, FieldOperand(scratch, WeakCell::kValueOffset));
-}
-
-
 void MacroAssembler::GetWeakValue(Register value, Handle<WeakCell> cell) {
   Move(value, cell, RelocInfo::EMBEDDED_OBJECT);
   movp(value, FieldOperand(value, WeakCell::kValueOffset));
 }
 
 
 void MacroAssembler::LoadWeakValue(Register value, Handle<WeakCell> cell,
                                    Label* miss) {
   GetWeakValue(value, cell);
   JumpIfSmi(value, miss);
@@ skipping 121 matching lines @@
          (((offset - SharedFunctionInfo::kLengthOffset) / kIntSize) % 2 == 1));
   if (kPointerSize == kInt64Size) {
     movsxlq(dst, FieldOperand(base, offset));
   } else {
     movp(dst, FieldOperand(base, offset));
     SmiToInteger32(dst, dst);
   }
 }
 
 
-void MacroAssembler::TestBitSharedFunctionInfoSpecialField(Register base,
-                                                           int offset,
-                                                           int bits) {
-  DCHECK(offset > SharedFunctionInfo::kLengthOffset &&
-         offset <= SharedFunctionInfo::kSize &&
-         (((offset - SharedFunctionInfo::kLengthOffset) / kIntSize) % 2 == 1));
-  if (kPointerSize == kInt32Size) {
-    // On x32, this field is represented by SMI.
-    bits += kSmiShift;
-  }
-  int byte_offset = bits / kBitsPerByte;
-  int bit_in_byte = bits & (kBitsPerByte - 1);
-  testb(FieldOperand(base, offset + byte_offset), Immediate(1 << bit_in_byte));
-}
-
-
 void MacroAssembler::Jump(ExternalReference ext) {
   LoadAddress(kScratchRegister, ext);
   jmp(kScratchRegister);
 }
 
 
 void MacroAssembler::Jump(const Operand& op) {
   if (kPointerSize == kInt64Size) {
     jmp(op);
   } else {
@@ skipping 315 matching lines @@
   Pop(r8);
   Pop(rdi);
   Pop(rsi);
   Pop(rbx);
   Pop(rdx);
   Pop(rcx);
   Pop(rax);
 }
 
 
-void MacroAssembler::Dropad() {
-  addp(rsp, Immediate(kNumSafepointRegisters * kPointerSize));
-}
-
-
 // Order general registers are pushed by Pushad:
 // rax, rcx, rdx, rbx, rsi, rdi, r8, r9, r11, r14, r15.
 const int
 MacroAssembler::kSafepointPushRegisterIndices[Register::kNumRegisters] = {
     0,
     1,
     2,
     3,
     -1,
     -1,
@@ skipping 254 matching lines @@
                                   AccessorComponent accessor) {
   movp(dst, FieldOperand(holder, HeapObject::kMapOffset));
   LoadInstanceDescriptors(dst, dst);
   movp(dst, FieldOperand(dst, DescriptorArray::GetValueOffset(accessor_index)));
   int offset = accessor == ACCESSOR_GETTER ? AccessorPair::kGetterOffset
                                            : AccessorPair::kSetterOffset;
   movp(dst, FieldOperand(dst, offset));
 }
 
 
-void MacroAssembler::DispatchWeakMap(Register obj, Register scratch1,
-                                     Register scratch2, Handle<WeakCell> cell,
-                                     Handle<Code> success,
-                                     SmiCheckType smi_check_type) {
-  Label fail;
-  if (smi_check_type == DO_SMI_CHECK) {
-    JumpIfSmi(obj, &fail);
-  }
-  movq(scratch1, FieldOperand(obj, HeapObject::kMapOffset));
-  CmpWeakValue(scratch1, cell, scratch2);
-  j(equal, success, RelocInfo::CODE_TARGET);
-  bind(&fail);
-}
-
-
-void MacroAssembler::AssertNumber(Register object) {
-  if (emit_debug_code()) {
-    Label ok;
-    Condition is_smi = CheckSmi(object);
-    j(is_smi, &ok, Label::kNear);
-    Cmp(FieldOperand(object, HeapObject::kMapOffset),
-        isolate()->factory()->heap_number_map());
-    Check(equal, kOperandIsNotANumber);
-    bind(&ok);
-  }
-}
-
-void MacroAssembler::AssertNotNumber(Register object) {
-  if (emit_debug_code()) {
-    Condition is_smi = CheckSmi(object);
-    Check(NegateCondition(is_smi), kOperandIsANumber);
-    Cmp(FieldOperand(object, HeapObject::kMapOffset),
-        isolate()->factory()->heap_number_map());
-    Check(not_equal, kOperandIsANumber);
-  }
-}
-
 void MacroAssembler::AssertNotSmi(Register object) {
   if (emit_debug_code()) {
     Condition is_smi = CheckSmi(object);
     Check(NegateCondition(is_smi), kOperandIsASmi);
   }
 }
 
 
 void MacroAssembler::AssertSmi(Register object) {
   if (emit_debug_code()) {
@@ skipping 14 matching lines @@
 void MacroAssembler::AssertZeroExtended(Register int32_register) {
   if (emit_debug_code()) {
     DCHECK(!int32_register.is(kScratchRegister));
     movq(kScratchRegister, V8_INT64_C(0x0000000100000000));
     cmpq(kScratchRegister, int32_register);
     Check(above_equal, k32BitValueInRegisterIsNotZeroExtended);
   }
 }
 
 
-void MacroAssembler::AssertString(Register object) {
-  if (emit_debug_code()) {
-    testb(object, Immediate(kSmiTagMask));
-    Check(not_equal, kOperandIsASmiAndNotAString);
-    Push(object);
-    movp(object, FieldOperand(object, HeapObject::kMapOffset));
-    CmpInstanceType(object, FIRST_NONSTRING_TYPE);
-    Pop(object);
-    Check(below, kOperandIsNotAString);
-  }
-}
-
-
-void MacroAssembler::AssertName(Register object) {
-  if (emit_debug_code()) {
-    testb(object, Immediate(kSmiTagMask));
-    Check(not_equal, kOperandIsASmiAndNotAName);
-    Push(object);
-    movp(object, FieldOperand(object, HeapObject::kMapOffset));
-    CmpInstanceType(object, LAST_NAME_TYPE);
-    Pop(object);
-    Check(below_equal, kOperandIsNotAName);
-  }
-}
-
-
 void MacroAssembler::AssertFunction(Register object) {
   if (emit_debug_code()) {
     testb(object, Immediate(kSmiTagMask));
     Check(not_equal, kOperandIsASmiAndNotAFunction);
     Push(object);
     CmpObjectType(object, JS_FUNCTION_TYPE, object);
     Pop(object);
     Check(equal, kOperandIsNotAFunction);
   }
 }
@@ skipping 14 matching lines @@
   if (emit_debug_code()) {
     testb(object, Immediate(kSmiTagMask));
     Check(not_equal, kOperandIsASmiAndNotAGeneratorObject);
     Push(object);
     CmpObjectType(object, JS_GENERATOR_OBJECT_TYPE, object);
     Pop(object);
     Check(equal, kOperandIsNotAGeneratorObject);
   }
 }
 
-void MacroAssembler::AssertReceiver(Register object) {
-  if (emit_debug_code()) {
-    testb(object, Immediate(kSmiTagMask));
-    Check(not_equal, kOperandIsASmiAndNotAReceiver);
-    Push(object);
-    STATIC_ASSERT(LAST_TYPE == LAST_JS_RECEIVER_TYPE);
-    CmpObjectType(object, FIRST_JS_RECEIVER_TYPE, object);
-    Pop(object);
-    Check(above_equal, kOperandIsNotAReceiver);
-  }
-}
-
-
 void MacroAssembler::AssertUndefinedOrAllocationSite(Register object) {
   if (emit_debug_code()) {
     Label done_checking;
     AssertNotSmi(object);
     Cmp(object, isolate()->factory()->undefined_value());
     j(equal, &done_checking);
     Cmp(FieldOperand(object, 0), isolate()->factory()->allocation_site_map());
     Assert(equal, kExpectedUndefinedOrCell);
     bind(&done_checking);
   }
 }
 
 
-void MacroAssembler::AssertRootValue(Register src,
-                                     Heap::RootListIndex root_value_index,
-                                     BailoutReason reason) {
-  if (emit_debug_code()) {
-    DCHECK(!src.is(kScratchRegister));
-    LoadRoot(kScratchRegister, root_value_index);
-    cmpp(src, kScratchRegister);
-    Check(equal, reason);
-  }
-}
-
-
-
 Condition MacroAssembler::IsObjectStringType(Register heap_object,
                                              Register map,
                                              Register instance_type) {
   movp(map, FieldOperand(heap_object, HeapObject::kMapOffset));
   movzxbl(instance_type, FieldOperand(map, Map::kInstanceTypeOffset));
   STATIC_ASSERT(kNotStringTag != 0);
   testb(instance_type, Immediate(kIsNotStringMask));
   return zero;
 }
 
 
-Condition MacroAssembler::IsObjectNameType(Register heap_object,
-                                           Register map,
-                                           Register instance_type) {
-  movp(map, FieldOperand(heap_object, HeapObject::kMapOffset));
-  movzxbl(instance_type, FieldOperand(map, Map::kInstanceTypeOffset));
-  cmpb(instance_type, Immediate(static_cast<uint8_t>(LAST_NAME_TYPE)));
-  return below_equal;
-}
-
-
 void MacroAssembler::SetCounter(StatsCounter* counter, int value) {
   if (FLAG_native_code_counters && counter->Enabled()) {
     Operand counter_operand = ExternalOperand(ExternalReference(counter));
     movl(counter_operand, Immediate(value));
   }
 }
 
 
 void MacroAssembler::IncrementCounter(StatsCounter* counter, int value) {
   DCHECK(value > 0);
@@ skipping 1233 matching lines @@
   movl(rax, dividend);
   shrl(rax, Immediate(31));
   addl(rdx, rax);
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_X64