Cleaned up CpuFeature scope handling.

src/ia32/stub-cache-ia32.cc

 // Copyright 2012 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 2029 matching lines @@
   //  -- esp[0]              : return address
   //  -- esp[(argc - n) * 4] : arg[n] (zero-based)
   //  -- ...
   //  -- esp[(argc + 1) * 4] : receiver
   // -----------------------------------
 
   if (!CpuFeatures::IsSupported(SSE2)) {
     return Handle<Code>::null();
   }
 
-  CpuFeatures::Scope use_sse2(SSE2);
+  CpuFeatureScope use_sse2(masm(), SSE2);
 
   const int argc = arguments().immediate();
 
   // If the object is not a JSObject or we got an unexpected number of
   // arguments, bail out to the regular call.
   if (!object->IsJSObject() || argc != 1) {
     return Handle<Code>::null();
   }
 
   Label miss;
@@ skipping 1130 matching lines @@
   Handle<SharedFunctionInfo> shared(function->shared());
   for (int i = 0; i < shared->this_property_assignments_count(); i++) {
     if (shared->IsThisPropertyAssignmentArgument(i)) {
       // Check if the argument assigned to the property is actually passed.
       // If argument is not passed the property is set to undefined,
       // otherwise find it on the stack.
       int arg_number = shared->GetThisPropertyAssignmentArgument(i);
       __ mov(ebx, edi);
       __ cmp(eax, arg_number);
       if (CpuFeatures::IsSupported(CMOV)) {
-        CpuFeatures::Scope use_cmov(CMOV);
+        CpuFeatureScope use_cmov(masm(), CMOV);
         __ cmov(above, ebx, Operand(ecx, arg_number * -kPointerSize));
       } else {
         Label not_passed;
         __ j(below_equal, &not_passed);
         __ mov(ebx, Operand(ecx, arg_number * -kPointerSize));
         __ bind(&not_passed);
       }
       // Store value in the property.
       __ mov(Operand(edx, i * kPointerSize), ebx);
     } else {
@@ skipping 92 matching lines @@
 
 static void GenerateSmiKeyCheck(MacroAssembler* masm,
                                 Register key,
                                 Register scratch,
                                 XMMRegister xmm_scratch0,
                                 XMMRegister xmm_scratch1,
                                 Label* fail) {
   // Check that key is a smi and if SSE2 is available a heap number
   // containing a smi and branch if the check fails.
   if (CpuFeatures::IsSupported(SSE2)) {
-    CpuFeatures::Scope use_sse2(SSE2);
+    CpuFeatureScope use_sse2(masm, SSE2);
     Label key_ok;
     __ JumpIfSmi(key, &key_ok);
     __ cmp(FieldOperand(key, HeapObject::kMapOffset),
            Immediate(Handle<Map>(masm->isolate()->heap()->heap_number_map())));
     __ j(not_equal, fail);
     __ movdbl(xmm_scratch0, FieldOperand(key, HeapNumber::kValueOffset));
     __ cvttsd2si(scratch, Operand(xmm_scratch0));
     __ cvtsi2sd(xmm_scratch1, scratch);
     __ ucomisd(xmm_scratch1, xmm_scratch0);
     __ j(not_equal, fail);
@@ skipping 116 matching lines @@
       // behavior.
 
       // For the moment we make the slow call to the runtime on
       // processors that don't support SSE2. The code in IntegerConvert
       // (code-stubs-ia32.cc) is roughly what is needed here though the
       // conversion failure case does not need to be handled.
       if (CpuFeatures::IsSupported(SSE2)) {
         if ((elements_kind == EXTERNAL_INT_ELEMENTS ||
              elements_kind == EXTERNAL_UNSIGNED_INT_ELEMENTS) &&
             CpuFeatures::IsSupported(SSE3)) {
-          CpuFeatures::Scope scope(SSE3);
+          CpuFeatureScope scope(masm, SSE3);
           // fisttp stores values as signed integers. To represent the
           // entire range of int and unsigned int arrays, store as a
           // 64-bit int and discard the high 32 bits.
           __ fld_d(FieldOperand(eax, HeapNumber::kValueOffset));
           __ sub(esp, Immediate(2 * kPointerSize));
           __ fisttp_d(Operand(esp, 0));
 
           // If conversion failed (NaN, infinity, or a number outside
           // signed int64 range), the result is 0x8000000000000000, and
           // we must handle this case in the runtime.
           Label ok;
           __ cmp(Operand(esp, kPointerSize), Immediate(0x80000000u));
           __ j(not_equal, &ok);
           __ cmp(Operand(esp, 0), Immediate(0));
           __ j(not_equal, &ok);
           __ add(esp, Immediate(2 * kPointerSize));  // Restore the stack.
           __ jmp(&slow);
 
           __ bind(&ok);
           __ pop(ebx);
           __ add(esp, Immediate(kPointerSize));
           __ mov(Operand(edi, ecx, times_2, 0), ebx);
         } else {
           ASSERT(CpuFeatures::IsSupported(SSE2));
-          CpuFeatures::Scope scope(SSE2);
+          CpuFeatureScope scope(masm, SSE2);
           __ cvttsd2si(ebx, FieldOperand(eax, HeapNumber::kValueOffset));
           __ cmp(ebx, 0x80000000u);
           __ j(equal, &slow);
           // ebx: untagged integer value
           switch (elements_kind) {
             case EXTERNAL_PIXEL_ELEMENTS:
               __ ClampUint8(ebx);
               // Fall through.
             case EXTERNAL_BYTE_ELEMENTS:
             case EXTERNAL_UNSIGNED_BYTE_ELEMENTS:
@@ skipping 339 matching lines @@
     __ jmp(ic_slow, RelocInfo::CODE_TARGET);
   }
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32