Remove NearLabel, replacing remaining occurrences with Label

src/ia32/code-stubs-ia32.cc

 // 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 587 matching lines @@
     case Token::BIT_NOT:
       GenerateSmiStubBitNot(masm);
       break;
     default:
       UNREACHABLE();
   }
 }
 
 
 void TypeRecordingUnaryOpStub::GenerateSmiStubSub(MacroAssembler* masm) {
-  NearLabel non_smi;
-  Label undo, slow;
-  GenerateSmiCodeSub(masm, &non_smi, &undo, &slow);
+  Label non_smi, undo, slow;
+  GenerateSmiCodeSub(masm, &non_smi, &undo, &slow,
+                     Label::kNear, Label::kNear, Label::kNear);
   __ bind(&undo);
   GenerateSmiCodeUndo(masm);
   __ bind(&non_smi);
   __ bind(&slow);
   GenerateTypeTransition(masm);
 }
 
 
 void TypeRecordingUnaryOpStub::GenerateSmiStubBitNot(MacroAssembler* masm) {
-  NearLabel non_smi;
+  Label non_smi;
   GenerateSmiCodeBitNot(masm, &non_smi);
   __ bind(&non_smi);
   GenerateTypeTransition(masm);
 }
 
 
-void TypeRecordingUnaryOpStub::GenerateSmiCodeSub(MacroAssembler* masm,
-                                                  NearLabel* non_smi,
-                                                  Label* undo,
-                                                  Label* slow) {
+void TypeRecordingUnaryOpStub::GenerateSmiCodeSub(
+    MacroAssembler* masm, Label* non_smi, Label* undo, Label* slow,
+    Label::Distance non_smi_near, Label::Distance undo_near,
+    Label::Distance slow_near) {
   // Check whether the value is a smi.
   __ test(eax, Immediate(kSmiTagMask));
-  __ j(not_zero, non_smi);
+  __ j(not_zero, non_smi, non_smi_near);
 
   // We can't handle -0 with smis, so use a type transition for that case.
   __ test(eax, Operand(eax));
-  __ j(zero, slow);
+  __ j(zero, slow, slow_near);
 
   // Try optimistic subtraction '0 - value', saving operand in eax for undo.
   __ mov(edx, Operand(eax));
   __ Set(eax, Immediate(0));
   __ sub(eax, Operand(edx));
-  __ j(overflow, undo);
+  __ j(overflow, undo, undo_near);
   __ ret(0);
 }
 
 
-void TypeRecordingUnaryOpStub::GenerateSmiCodeBitNot(MacroAssembler* masm,
-                                                     NearLabel* non_smi) {
+void TypeRecordingUnaryOpStub::GenerateSmiCodeBitNot(
+    MacroAssembler* masm,
+    Label* non_smi,
+    Label::Distance non_smi_near) {
   // Check whether the value is a smi.
   __ test(eax, Immediate(kSmiTagMask));
-  __ j(not_zero, non_smi);
+  __ j(not_zero, non_smi, non_smi_near);
 
   // Flip bits and revert inverted smi-tag.
   __ not_(eax);
   __ and_(eax, ~kSmiTagMask);
   __ ret(0);
 }
 
 
 void TypeRecordingUnaryOpStub::GenerateSmiCodeUndo(MacroAssembler* masm) {
   __ mov(eax, Operand(edx));
 }
 
 
 // TODO(svenpanne): Use virtual functions instead of switch.
 void TypeRecordingUnaryOpStub::GenerateHeapNumberStub(MacroAssembler* masm) {
   switch (op_) {
     case Token::SUB:
       GenerateHeapNumberStubSub(masm);
       break;
     case Token::BIT_NOT:
       GenerateHeapNumberStubBitNot(masm);
       break;
     default:
       UNREACHABLE();
   }
 }
 
 
 void TypeRecordingUnaryOpStub::GenerateHeapNumberStubSub(MacroAssembler* masm) {
-  NearLabel non_smi;
-  Label undo, slow;
-  GenerateSmiCodeSub(masm, &non_smi, &undo, &slow);
+  Label non_smi, undo, slow;
+  GenerateSmiCodeSub(masm, &non_smi, &undo, &slow, Label::kNear);
   __ bind(&non_smi);
   GenerateHeapNumberCodeSub(masm, &slow);
   __ bind(&undo);
   GenerateSmiCodeUndo(masm);
   __ bind(&slow);
   GenerateTypeTransition(masm);
 }
 
 
 void TypeRecordingUnaryOpStub::GenerateHeapNumberStubBitNot(
     MacroAssembler* masm) {
-  NearLabel non_smi;
-  Label slow;
-  GenerateSmiCodeBitNot(masm, &non_smi);
+  Label non_smi, slow;
+  GenerateSmiCodeBitNot(masm, &non_smi, Label::kNear);
   __ bind(&non_smi);
   GenerateHeapNumberCodeBitNot(masm, &slow);
   __ bind(&slow);
   GenerateTypeTransition(masm);
 }
 
 
 void TypeRecordingUnaryOpStub::GenerateHeapNumberCodeSub(MacroAssembler* masm,
                                                          Label* slow) {
   __ mov(edx, FieldOperand(eax, HeapObject::kMapOffset));
@@ skipping 91 matching lines @@
     case Token::BIT_NOT:
       GenerateGenericStubBitNot(masm);
       break;
     default:
       UNREACHABLE();
   }
 }
 
 
 void TypeRecordingUnaryOpStub::GenerateGenericStubSub(MacroAssembler* masm)  {
-  NearLabel non_smi;
-  Label undo, slow;
-  GenerateSmiCodeSub(masm, &non_smi, &undo, &slow);
+  Label non_smi, undo, slow;
+  GenerateSmiCodeSub(masm, &non_smi, &undo, &slow, Label::kNear);
   __ bind(&non_smi);
   GenerateHeapNumberCodeSub(masm, &slow);
   __ bind(&undo);
   GenerateSmiCodeUndo(masm);
   __ bind(&slow);
   GenerateGenericCodeFallback(masm);
 }
 
 
 void TypeRecordingUnaryOpStub::GenerateGenericStubBitNot(MacroAssembler* masm) {
-  NearLabel non_smi;
-  Label slow;
-  GenerateSmiCodeBitNot(masm, &non_smi);
+  Label non_smi, slow;
+  GenerateSmiCodeBitNot(masm, &non_smi, Label::kNear);
   __ bind(&non_smi);
   GenerateHeapNumberCodeBitNot(masm, &slow);
   __ bind(&slow);
   GenerateGenericCodeFallback(masm);
 }
 
 
 void TypeRecordingUnaryOpStub::GenerateGenericCodeFallback(
     MacroAssembler* masm) {
   // Handle the slow case by jumping to the corresponding JavaScript builtin.
@@ skipping 4777 matching lines @@
 
 
 void StringCompareStub::GenerateFlatAsciiStringEquals(MacroAssembler* masm,
                                                       Register left,
                                                       Register right,
                                                       Register scratch1,
                                                       Register scratch2) {
   Register length = scratch1;
 
   // Compare lengths.
-  NearLabel strings_not_equal;
-  Label check_zero_length;
+  Label strings_not_equal, check_zero_length;
   __ mov(length, FieldOperand(left, String::kLengthOffset));
   __ cmp(length, FieldOperand(right, String::kLengthOffset));
   __ j(equal, &check_zero_length, Label::kNear);
   __ bind(&strings_not_equal);
   __ Set(eax, Immediate(Smi::FromInt(NOT_EQUAL)));
   __ ret(0);
 
   // Check if the length is zero.
   Label compare_chars;
   __ bind(&check_zero_length);
   STATIC_ASSERT(kSmiTag == 0);
   __ test(length, Operand(length));
   __ j(not_zero, &compare_chars, Label::kNear);
   __ Set(eax, Immediate(Smi::FromInt(EQUAL)));
   __ ret(0);
 
   // Compare characters.
   __ bind(&compare_chars);
   GenerateAsciiCharsCompareLoop(masm, left, right, length, scratch2,
-                                &strings_not_equal);
+                                &strings_not_equal, Label::kNear);
 
   // Characters are equal.
   __ Set(eax, Immediate(Smi::FromInt(EQUAL)));
   __ ret(0);
 }
 
 
 void StringCompareStub::GenerateCompareFlatAsciiStrings(MacroAssembler* masm,
                                                         Register left,
                                                         Register right,
@@ skipping 17 matching lines @@
   __ bind(&left_shorter);
 
   Register min_length = scratch1;
 
   // If either length is zero, just compare lengths.
   Label compare_lengths;
   __ test(min_length, Operand(min_length));
   __ j(zero, &compare_lengths, Label::kNear);
 
   // Compare characters.
-  NearLabel result_not_equal;
+  Label result_not_equal;
   GenerateAsciiCharsCompareLoop(masm, left, right, min_length, scratch2,
-                                &result_not_equal);
+                                &result_not_equal, Label::kNear);
 
   // Compare lengths -  strings up to min-length are equal.
   __ bind(&compare_lengths);
   __ test(length_delta, Operand(length_delta));
-  __ j(not_zero, &result_not_equal);
+  __ j(not_zero, &result_not_equal, Label::kNear);
 
   // Result is EQUAL.
   STATIC_ASSERT(EQUAL == 0);
   STATIC_ASSERT(kSmiTag == 0);
   __ Set(eax, Immediate(Smi::FromInt(EQUAL)));
   __ ret(0);
 
   Label result_greater;
   __ bind(&result_not_equal);
   __ j(greater, &result_greater, Label::kNear);
 
   // Result is LESS.
   __ Set(eax, Immediate(Smi::FromInt(LESS)));
   __ ret(0);
 
   // Result is GREATER.
   __ bind(&result_greater);
   __ Set(eax, Immediate(Smi::FromInt(GREATER)));
   __ ret(0);
 }
 
 
 void StringCompareStub::GenerateAsciiCharsCompareLoop(
     MacroAssembler* masm,
     Register left,
     Register right,
     Register length,
     Register scratch,
-    NearLabel* chars_not_equal) {
+    Label* chars_not_equal,
+    Label::Distance chars_not_equal_near) {
   // Change index to run from -length to -1 by adding length to string
   // start. This means that loop ends when index reaches zero, which
   // doesn't need an additional compare.
   __ SmiUntag(length);
   __ lea(left,
          FieldOperand(left, length, times_1, SeqAsciiString::kHeaderSize));
   __ lea(right,
          FieldOperand(right, length, times_1, SeqAsciiString::kHeaderSize));
   __ neg(length);
   Register index = length;  // index = -length;
 
   // Compare loop.
   Label loop;
   __ bind(&loop);
   __ mov_b(scratch, Operand(left, index, times_1, 0));
   __ cmpb(scratch, Operand(right, index, times_1, 0));
-  __ j(not_equal, chars_not_equal);
+  __ j(not_equal, chars_not_equal, chars_not_equal_near);
   __ add(Operand(index), Immediate(1));
   __ j(not_zero, &loop);
 }
 
 
 void StringCompareStub::Generate(MacroAssembler* masm) {
   Label runtime;
 
   // Stack frame on entry.
   //  esp[0]: return address
@@ skipping 497 matching lines @@
   __ Drop(1);
   __ ret(2 * kPointerSize);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32