Fixing style issues in codegen-ia32.*...

src/ia32/codegen-ia32.cc

 // Copyright 2006-2009 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 723 matching lines @@
   frame_->Push(&value);  // Undo the Pop() from above.
   ToBooleanStub stub;
   Result temp = frame_->CallStub(&stub, 1);
   // Convert the result to a condition code.
   __ test(temp.reg(), Operand(temp.reg()));
   temp.Unuse();
   dest->Split(not_equal);
 }
 
 
-enum ArgLocation {
-  ARGS_ON_STACK,
-  ARGS_IN_REGISTERS
-};
-
-
 class FloatingPointHelper : public AllStatic {
  public:
+
+  enum ArgLocation {
+    ARGS_ON_STACK,
+    ARGS_IN_REGISTERS
+  };
+
   // Code pattern for loading a floating point value. Input value must
   // be either a smi or a heap number object (fp value). Requirements:
   // operand in register number. Returns operand as floating point number
   // on FPU stack.
   static void LoadFloatOperand(MacroAssembler* masm, Register number);
   // Code pattern for loading floating point values. Input values must
   // be either smi or heap number objects (fp values). Requirements:
   // operand_1 on TOS+1 or in edx, operand_2 on TOS+2 or in eax.
   // Returns operands as floating point numbers on FPU stack.
   static void LoadFloatOperands(MacroAssembler* masm,
@@ skipping 6308 matching lines @@
     SetArgsInRegisters();
     __ IncrementCounter(&Counters::generic_binary_stub_calls_regs, 1);
   }
 
   // Call the stub.
   __ CallStub(this);
 }
 
 
 void GenericBinaryOpStub::GenerateSmiCode(MacroAssembler* masm, Label* slow) {
-  if (HasArgumentsInRegisters()) {
+  if (HasArgsInRegisters()) {
     __ mov(ebx, eax);
     __ mov(eax, edx);
   } else {
     __ mov(ebx, Operand(esp, 1 * kPointerSize));
     __ mov(eax, Operand(esp, 2 * kPointerSize));
   }
 
   Label not_smis, not_smis_or_overflow, not_smis_undo_optimistic;
   Label use_fp_on_smis, done;
 
@@ skipping 151 matching lines @@
 
   __ bind(&use_fp_on_smis);
   // Both operands are known to be SMIs but the result does not fit into a SMI.
   switch (op_) {
     case Token::ADD:
     case Token::SUB:
     case Token::MUL:
     case Token::DIV: {
       Label after_alloc_failure;
 
-      ArgLocation arg_location =
+      FloatingPointHelper::ArgLocation arg_location =
           (op_ == Token::ADD || op_ == Token::SUB) ?
-          ARGS_IN_REGISTERS :
-          ARGS_ON_STACK;
+          FloatingPointHelper::ARGS_IN_REGISTERS :
+          FloatingPointHelper::ARGS_ON_STACK;
 
       __ AllocateHeapNumber(
           edx,
           ecx,
           no_reg,
-          arg_location == ARGS_IN_REGISTERS ? &after_alloc_failure : slow);
+          arg_location == FloatingPointHelper::ARGS_IN_REGISTERS ?
+              &after_alloc_failure :
+              slow);
 
       if (CpuFeatures::IsSupported(SSE2)) {
         CpuFeatures::Scope use_sse2(SSE2);
         FloatingPointHelper::LoadSse2Smis(masm, ecx, arg_location);
         switch (op_) {
           case Token::ADD: __ addsd(xmm0, xmm1); break;
           case Token::SUB: __ subsd(xmm0, xmm1); break;
           case Token::MUL: __ mulsd(xmm0, xmm1); break;
           case Token::DIV: __ divsd(xmm0, xmm1); break;
           default: UNREACHABLE();
         }
         __ movdbl(FieldOperand(edx, HeapNumber::kValueOffset), xmm0);
       } else {  // SSE2 not available, use FPU.
         FloatingPointHelper::LoadFloatSmis(masm, ecx, arg_location);
         switch (op_) {
           case Token::ADD: __ faddp(1); break;
           case Token::SUB: __ fsubp(1); break;
           case Token::MUL: __ fmulp(1); break;
           case Token::DIV: __ fdivp(1); break;
           default: UNREACHABLE();
         }
         __ fstp_d(FieldOperand(edx, HeapNumber::kValueOffset));
       }
       __ mov(eax, edx);
       GenerateReturn(masm);
 
-      if (arg_location == ARGS_IN_REGISTERS) {
+      if (arg_location == FloatingPointHelper::ARGS_IN_REGISTERS) {
         __ bind(&after_alloc_failure);
         __ mov(edx, eax);
         __ mov(eax, ebx);
         __ jmp(slow);
       }
+      break;
     }
+
     case Token::BIT_OR:
     case Token::BIT_AND:
     case Token::BIT_XOR:
     case Token::SAR:
       // Do nothing here as these operations always succeed on a pair of smis.
       break;
 
     case Token::MOD:
     case Token::SHR:
       // Do nothing here as these go directly to runtime.
@@ skipping 63 matching lines @@
           case Token::SUB: __ subsd(xmm0, xmm1); break;
           case Token::MUL: __ mulsd(xmm0, xmm1); break;
           case Token::DIV: __ divsd(xmm0, xmm1); break;
           default: UNREACHABLE();
         }
         GenerateHeapResultAllocation(masm, &call_runtime);
         __ movdbl(FieldOperand(eax, HeapNumber::kValueOffset), xmm0);
         GenerateReturn(masm);
       } else {  // SSE2 not available, use FPU.
         FloatingPointHelper::CheckFloatOperands(masm, &call_runtime, ebx);
-        FloatingPointHelper::LoadFloatOperands(masm, ecx, ARGS_IN_REGISTERS);
+        FloatingPointHelper::LoadFloatOperands(
+            masm,
+            ecx,
+            FloatingPointHelper::ARGS_IN_REGISTERS);
         switch (op_) {
           case Token::ADD: __ faddp(1); break;
           case Token::SUB: __ fsubp(1); break;
           case Token::MUL: __ fmulp(1); break;
           case Token::DIV: __ fdivp(1); break;
           default: UNREACHABLE();
         }
         Label after_alloc_failure;
         GenerateHeapResultAllocation(masm, &after_alloc_failure);
         __ fstp_d(FieldOperand(eax, HeapNumber::kValueOffset));
@@ skipping 73 matching lines @@
       }
       break;
     }
     default: UNREACHABLE(); break;
   }
 
   // If all else fails, use the runtime system to get the correct
   // result. If arguments was passed in registers now place them on the
   // stack in the correct order below the return address.
   __ bind(&call_runtime);
-  if (HasArgumentsInRegisters()) {
+  if (HasArgsInRegisters()) {
     __ pop(ecx);
-    if (HasArgumentsReversed()) {
+    if (HasArgsReversed()) {
       __ push(eax);
       __ push(edx);
     } else {
       __ push(edx);
       __ push(eax);
     }
     __ push(ecx);
   }
   switch (op_) {
     case Token::ADD: {
@@ skipping 11 matching lines @@
       __ CmpObjectType(eax, FIRST_NONSTRING_TYPE, ecx);
       __ j(above_equal, &string1);
 
       // First and second argument are strings. Jump to the string add stub.
       StringAddStub stub(NO_STRING_CHECK_IN_STUB);
       __ TailCallStub(&stub);
 
       // Only first argument is a string.
       __ bind(&string1);
       __ InvokeBuiltin(
-          HasArgumentsReversed() ?
+          HasArgsReversed() ?
               Builtins::STRING_ADD_RIGHT :
               Builtins::STRING_ADD_LEFT,
-         JUMP_FUNCTION);
+          JUMP_FUNCTION);
 
       // First argument was not a string, test second.
       __ bind(&not_string1);
       __ test(eax, Immediate(kSmiTagMask));
       __ j(zero, &not_strings);
       __ CmpObjectType(eax, FIRST_NONSTRING_TYPE, ecx);
       __ j(above_equal, &not_strings);
 
       // Only second argument is a string.
       __ InvokeBuiltin(
-          HasArgumentsReversed() ?
+          HasArgsReversed() ?
               Builtins::STRING_ADD_LEFT :
               Builtins::STRING_ADD_RIGHT,
-         JUMP_FUNCTION);
+          JUMP_FUNCTION);
 
       __ bind(&not_strings);
       // Neither argument is a string.
       __ InvokeBuiltin(Builtins::ADD, JUMP_FUNCTION);
       break;
     }
     case Token::SUB:
       __ InvokeBuiltin(Builtins::SUB, JUMP_FUNCTION);
       break;
     case Token::MUL:
@@ skipping 26 matching lines @@
     default:
       UNREACHABLE();
   }
 }
 
 
 void GenericBinaryOpStub::GenerateHeapResultAllocation(MacroAssembler* masm,
                                                        Label* alloc_failure) {
   Label skip_allocation;
   OverwriteMode mode = mode_;
-  if (HasArgumentsReversed()) {
+  if (HasArgsReversed()) {
     if (mode == OVERWRITE_RIGHT) {
       mode = OVERWRITE_LEFT;
     } else if (mode == OVERWRITE_LEFT) {
       mode = OVERWRITE_RIGHT;
     }
   }
   switch (mode) {
     case OVERWRITE_LEFT: {
       // If the argument in edx is already an object, we skip the
       // allocation of a heap number.
@@ skipping 25 matching lines @@
       __ mov(eax, ebx);
       __ bind(&skip_allocation);
       break;
     default: UNREACHABLE();
   }
 }
 
 
 void GenericBinaryOpStub::GenerateLoadArguments(MacroAssembler* masm) {
   // If arguments are not passed in registers read them from the stack.
-  if (!HasArgumentsInRegisters()) {
+  if (!HasArgsInRegisters()) {
     __ mov(eax, Operand(esp, 1 * kPointerSize));
     __ mov(edx, Operand(esp, 2 * kPointerSize));
   }
 }
 
 
 void GenericBinaryOpStub::GenerateReturn(MacroAssembler* masm) {
   // If arguments are not passed in registers remove them from the stack before
   // returning.
-  if (!HasArgumentsInRegisters()) {
+  if (!HasArgsInRegisters()) {
     __ ret(2 * kPointerSize);  // Remove both operands
   } else {
     __ ret(0);
   }
 }
 
 
 // Get the integer part of a heap number.  Surprisingly, all this bit twiddling
 // is faster than using the built-in instructions on floating point registers.
 // Trashes edi and ebx.  Dest is ecx.  Source cannot be ecx or one of the
@@ skipping 2344 matching lines @@
 
   // Call the runtime; it returns -1 (less), 0 (equal), or 1 (greater)
   // tagged as a small integer.
   __ bind(&runtime);
   __ TailCallRuntime(ExternalReference(Runtime::kStringCompare), 2, 1);
 }
 
 #undef __
 
 } }  // namespace v8::internal