Merge Label and NearLabel

src/x64/macro-assembler-x64.h

 // Copyright 2011 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 1351 matching lines @@
 void MacroAssembler::SmiMul(Register dst,
                             Register src1,
                             Register src2,
                             LabelType* on_not_smi_result) {
   ASSERT(!dst.is(src2));
   ASSERT(!dst.is(kScratchRegister));
   ASSERT(!src1.is(kScratchRegister));
   ASSERT(!src2.is(kScratchRegister));
 
   if (dst.is(src1)) {
-    NearLabel failure, zero_correct_result;
+    Label failure, zero_correct_result;
     movq(kScratchRegister, src1);  // Create backup for later testing.
     SmiToInteger64(dst, src1);
     imul(dst, src2);
-    j(overflow, &failure);
+    j(overflow, &failure, Label::kNear);
 
     // Check for negative zero result.  If product is zero, and one
     // argument is negative, go to slow case.
-    NearLabel correct_result;
+    Label correct_result;
     testq(dst, dst);
-    j(not_zero, &correct_result);
+    j(not_zero, &correct_result, Label::kNear);
 
     movq(dst, kScratchRegister);
     xor_(dst, src2);
-    j(positive, &zero_correct_result);  // Result was positive zero.
+    // Result was positive zero.
+    j(positive, &zero_correct_result, Label::kNear);
 
     bind(&failure);  // Reused failure exit, restores src1.
     movq(src1, kScratchRegister);
     jmp(on_not_smi_result);
 
     bind(&zero_correct_result);
     Set(dst, 0);
 
     bind(&correct_result);
   } else {
     SmiToInteger64(dst, src1);
     imul(dst, src2);
     j(overflow, on_not_smi_result);
     // Check for negative zero result.  If product is zero, and one
     // argument is negative, go to slow case.
-    NearLabel correct_result;
+    Label correct_result;
     testq(dst, dst);
-    j(not_zero, &correct_result);
+    j(not_zero, &correct_result, Label::kNear);
     // One of src1 and src2 is zero, the check whether the other is
     // negative.
     movq(kScratchRegister, src1);
     xor_(kScratchRegister, src2);
     j(negative, on_not_smi_result);
     bind(&correct_result);
   }
 }
 
 
@@ skipping 94 matching lines @@
                             Register src2,
                             LabelType* on_not_smi_result) {
   ASSERT(!src1.is(kScratchRegister));
   ASSERT(!src2.is(kScratchRegister));
   ASSERT(!dst.is(kScratchRegister));
   ASSERT(!src2.is(rax));
   ASSERT(!src2.is(rdx));
   ASSERT(!src1.is(rdx));
 
   // Check for 0 divisor (result is +/-Infinity).
-  NearLabel positive_divisor;
   testq(src2, src2);
   j(zero, on_not_smi_result);
 
   if (src1.is(rax)) {
     movq(kScratchRegister, src1);
   }
   SmiToInteger32(rax, src1);
   // We need to rule out dividing Smi::kMinValue by -1, since that would
   // overflow in idiv and raise an exception.
   // We combine this with negative zero test (negative zero only happens
   // when dividing zero by a negative number).
 
   // We overshoot a little and go to slow case if we divide min-value
   // by any negative value, not just -1.
-  NearLabel safe_div;
+  Label safe_div;
   testl(rax, Immediate(0x7fffffff));
-  j(not_zero, &safe_div);
+  j(not_zero, &safe_div, Label::kNear);
   testq(src2, src2);
   if (src1.is(rax)) {
-    j(positive, &safe_div);
+    j(positive, &safe_div, Label::kNear);
     movq(src1, kScratchRegister);
     jmp(on_not_smi_result);
   } else {
     j(negative, on_not_smi_result);
   }
   bind(&safe_div);
 
   SmiToInteger32(src2, src2);
   // Sign extend src1 into edx:eax.
   cdq();
   idivl(src2);
   Integer32ToSmi(src2, src2);
   // Check that the remainder is zero.
   testl(rdx, rdx);
   if (src1.is(rax)) {
-    NearLabel smi_result;
-    j(zero, &smi_result);
+    Label smi_result;
+    j(zero, &smi_result, Label::kNear);
     movq(src1, kScratchRegister);
     jmp(on_not_smi_result);
     bind(&smi_result);
   } else {
     j(not_zero, on_not_smi_result);
   }
   if (!dst.is(src1) && src1.is(rax)) {
     movq(src1, kScratchRegister);
   }
   Integer32ToSmi(dst, rax);
@@ skipping 16 matching lines @@
   testq(src2, src2);
   j(zero, on_not_smi_result);
 
   if (src1.is(rax)) {
     movq(kScratchRegister, src1);
   }
   SmiToInteger32(rax, src1);
   SmiToInteger32(src2, src2);
 
   // Test for the edge case of dividing Smi::kMinValue by -1 (will overflow).
-  NearLabel safe_div;
+  Label safe_div;
   cmpl(rax, Immediate(Smi::kMinValue));
-  j(not_equal, &safe_div);
+  j(not_equal, &safe_div, Label::kNear);
   cmpl(src2, Immediate(-1));
-  j(not_equal, &safe_div);
+  j(not_equal, &safe_div, Label::kNear);
   // Retag inputs and go slow case.
   Integer32ToSmi(src2, src2);
   if (src1.is(rax)) {
     movq(src1, kScratchRegister);
   }
   jmp(on_not_smi_result);
   bind(&safe_div);
 
   // Sign extend eax into edx:eax.
   cdq();
   idivl(src2);
   // Restore smi tags on inputs.
   Integer32ToSmi(src2, src2);
   if (src1.is(rax)) {
     movq(src1, kScratchRegister);
   }
   // Check for a negative zero result.  If the result is zero, and the
   // dividend is negative, go slow to return a floating point negative zero.
-  NearLabel smi_result;
+  Label smi_result;
   testl(rdx, rdx);
-  j(not_zero, &smi_result);
+  j(not_zero, &smi_result, Label::kNear);
   testq(src1, src1);
   j(negative, on_not_smi_result);
   bind(&smi_result);
   Integer32ToSmi(dst, rdx);
 }
 
 
 template <typename LabelType>
 void MacroAssembler::SmiShiftLogicalRightConstant(
     Register dst, Register src, int shift_value, LabelType* on_not_smi_result) {
@@ skipping 16 matching lines @@
 void MacroAssembler::SmiShiftLogicalRight(Register dst,
                                           Register src1,
                                           Register src2,
                                           LabelType* on_not_smi_result) {
   ASSERT(!dst.is(kScratchRegister));
   ASSERT(!src1.is(kScratchRegister));
   ASSERT(!src2.is(kScratchRegister));
   ASSERT(!dst.is(rcx));
   // dst and src1 can be the same, because the one case that bails out
   // is a shift by 0, which leaves dst, and therefore src1, unchanged.
-  NearLabel result_ok;
   if (src1.is(rcx) || src2.is(rcx)) {
     movq(kScratchRegister, rcx);
   }
   if (!dst.is(src1)) {
     movq(dst, src1);
   }
   SmiToInteger32(rcx, src2);
   orl(rcx, Immediate(kSmiShift));
   shr_cl(dst);  // Shift is rcx modulo 0x1f + 32.
   shl(dst, Immediate(kSmiShift));
   testq(dst, dst);
   if (src1.is(rcx) || src2.is(rcx)) {
-    NearLabel positive_result;
-    j(positive, &positive_result);
+    Label positive_result;
+    j(positive, &positive_result, Label::kNear);
     if (src1.is(rcx)) {
       movq(src1, kScratchRegister);
     } else {
       movq(src2, kScratchRegister);
     }
     jmp(on_not_smi_result);
     bind(&positive_result);
   } else {
     j(negative, on_not_smi_result);  // src2 was zero and src1 negative.
   }
@@ skipping 251 matching lines @@
 
 template <typename LabelType>
 void MacroAssembler::InvokePrologue(const ParameterCount& expected,
                                     const ParameterCount& actual,
                                     Handle<Code> code_constant,
                                     Register code_register,
                                     LabelType* done,
                                     InvokeFlag flag,
                                     const CallWrapper& call_wrapper) {
   bool definitely_matches = false;
-  NearLabel invoke;
+  Label invoke;
   if (expected.is_immediate()) {
     ASSERT(actual.is_immediate());
     if (expected.immediate() == actual.immediate()) {
       definitely_matches = true;
     } else {
       Set(rax, actual.immediate());
       if (expected.immediate() ==
               SharedFunctionInfo::kDontAdaptArgumentsSentinel) {
         // Don't worry about adapting arguments for built-ins that
         // don't want that done. Skip adaption code by making it look
         // like we have a match between expected and actual number of
         // arguments.
         definitely_matches = true;
       } else {
         Set(rbx, expected.immediate());
       }
     }
   } else {
     if (actual.is_immediate()) {
       // Expected is in register, actual is immediate. This is the
       // case when we invoke function values without going through the
       // IC mechanism.
       cmpq(expected.reg(), Immediate(actual.immediate()));
-      j(equal, &invoke);
+      j(equal, &invoke, Label::kNear);
       ASSERT(expected.reg().is(rbx));
       Set(rax, actual.immediate());
     } else if (!expected.reg().is(actual.reg())) {
       // Both expected and actual are in (different) registers. This
       // is the case when we invoke functions using call and apply.
       cmpq(expected.reg(), actual.reg());
-      j(equal, &invoke);
+      j(equal, &invoke, Label::kNear);
       ASSERT(actual.reg().is(rax));
       ASSERT(expected.reg().is(rbx));
     }
   }
 
   if (!definitely_matches) {
     Handle<Code> adaptor = isolate()->builtins()->ArgumentsAdaptorTrampoline();
     if (!code_constant.is_null()) {
       movq(rdx, code_constant, RelocInfo::EMBEDDED_OBJECT);
       addq(rdx, Immediate(Code::kHeaderSize - kHeapObjectTag));
@@ skipping 10 matching lines @@
       Jump(adaptor, RelocInfo::CODE_TARGET);
     }
     bind(&invoke);
   }
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_X64_MACRO_ASSEMBLER_X64_H_