ia32: Helper function for getting an element of a fixed array from object poi...

src/ia32/codegen-ia32.cc

 // Copyright 2010 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 4209 matching lines @@
   // targets only after all the state is pushed on the frame.
   node->break_target()->set_direction(JumpTarget::FORWARD_ONLY);
   node->continue_target()->set_direction(JumpTarget::FORWARD_ONLY);
 
   __ mov(eax, frame_->ElementAt(0));  // load the current count
   __ cmp(eax, frame_->ElementAt(1));  // compare to the array length
   node->break_target()->Branch(above_equal);
 
   // Get the i'th entry of the array.
   __ mov(edx, frame_->ElementAt(2));
-  __ mov(ebx, Operand(edx, eax, times_2,
-                      FixedArray::kHeaderSize - kHeapObjectTag));
+  __ mov(ebx, FixedArrayElementOperand(edx, eax));
 
   // Get the expected map from the stack or a zero map in the
   // permanent slow case eax: current iteration count ebx: i'th entry
   // of the enum cache
   __ mov(edx, frame_->ElementAt(3));
   // Check if the expected map still matches that of the enumerable.
   // If not, we have to filter the key.
   // eax: current iteration count
   // ebx: i'th entry of the enum cache
   // edx: expected map value
@@ skipping 2385 matching lines @@
   virtual void Generate();
 
  private:
   Register dst_;    // on invocation Smi index of finger, on exit
                     // holds value being looked up.
   Register cache_;  // instance of JSFunctionResultCache.
   Register key_;    // key being looked up.
 };
 
 
-// Return a position of the element at |index_as_smi| + |additional_offset|
-// in FixedArray pointer to which is held in |array|.  |index_as_smi| is Smi.
-static Operand ArrayElement(Register array,
-                            Register index_as_smi,
-                            int additional_offset = 0) {
-  int offset = FixedArray::kHeaderSize + additional_offset * kPointerSize;
-  return FieldOperand(array, index_as_smi, times_half_pointer_size, offset);
-}
-
-
 void DeferredSearchCache::Generate() {
   Label first_loop, search_further, second_loop, cache_miss;
 
   // Smi-tagging is equivalent to multiplying by 2.
   STATIC_ASSERT(kSmiTag == 0);
   STATIC_ASSERT(kSmiTagSize == 1);
 
   Smi* kEntrySizeSmi = Smi::FromInt(JSFunctionResultCache::kEntrySize);
   Smi* kEntriesIndexSmi = Smi::FromInt(JSFunctionResultCache::kEntriesIndex);
 
   // Check the cache from finger to start of the cache.
   __ bind(&first_loop);
   __ sub(Operand(dst_), Immediate(kEntrySizeSmi));
   __ cmp(Operand(dst_), Immediate(kEntriesIndexSmi));
   __ j(less, &search_further);
 
-  __ cmp(key_, ArrayElement(cache_, dst_));
+  __ cmp(key_, CodeGenerator::FixedArrayElementOperand(cache_, dst_));
   __ j(not_equal, &first_loop);
 
   __ mov(FieldOperand(cache_, JSFunctionResultCache::kFingerOffset), dst_);
-  __ mov(dst_, ArrayElement(cache_, dst_, 1));
+  __ mov(dst_, CodeGenerator::FixedArrayElementOperand(cache_, dst_, 1));
   __ jmp(exit_label());
 
   __ bind(&search_further);
 
   // Check the cache from end of cache up to finger.
   __ mov(dst_, FieldOperand(cache_, JSFunctionResultCache::kCacheSizeOffset));
 
   __ bind(&second_loop);
   __ sub(Operand(dst_), Immediate(kEntrySizeSmi));
     // Consider prefetching into some reg.
   __ cmp(dst_, FieldOperand(cache_, JSFunctionResultCache::kFingerOffset));
   __ j(less_equal, &cache_miss);
 
-  __ cmp(key_, ArrayElement(cache_, dst_));
+  __ cmp(key_, CodeGenerator::FixedArrayElementOperand(cache_, dst_));
   __ j(not_equal, &second_loop);
 
   __ mov(FieldOperand(cache_, JSFunctionResultCache::kFingerOffset), dst_);
-  __ mov(dst_, ArrayElement(cache_, dst_, 1));
+  __ mov(dst_, CodeGenerator::FixedArrayElementOperand(cache_, dst_, 1));
   __ jmp(exit_label());
 
   __ bind(&cache_miss);
   __ push(cache_);  // store a reference to cache
   __ push(key_);  // store a key
   Handle<Object> receiver(Top::global_context()->global());
   __ push(Immediate(receiver));
   __ push(key_);
   // On ia32 function must be in edi.
   __ mov(edi, FieldOperand(cache_, JSFunctionResultCache::kFactoryOffset));
@@ skipping 27 matching lines @@
   __ mov(edx, FieldOperand(ecx, JSFunctionResultCache::kCacheSizeOffset));
   __ lea(ebx, Operand(edx, JSFunctionResultCache::kEntrySize << 1));
   __ mov(FieldOperand(ecx, JSFunctionResultCache::kCacheSizeOffset), ebx);
 
   // Update the cache itself.
   // edx holds the index.
   __ bind(&update_cache);
   __ pop(ebx);  // restore the key
   __ mov(FieldOperand(ecx, JSFunctionResultCache::kFingerOffset), edx);
   // Store key.
-  __ mov(ArrayElement(ecx, edx), ebx);
+  __ mov(CodeGenerator::FixedArrayElementOperand(ecx, edx), ebx);
   __ RecordWrite(ecx, 0, ebx, edx);
 
   // Store value.
   __ pop(ecx);  // restore the cache.
   __ mov(edx, FieldOperand(ecx, JSFunctionResultCache::kFingerOffset));
   __ add(Operand(edx), Immediate(Smi::FromInt(1)));
   __ mov(ebx, eax);
-  __ mov(ArrayElement(ecx, edx), ebx);
+  __ mov(CodeGenerator::FixedArrayElementOperand(ecx, edx), ebx);
   __ RecordWrite(ecx, 0, ebx, edx);
 
   if (!dst_.is(eax)) {
     __ mov(dst_, eax);
   }
 }
 
 
 void CodeGenerator::GenerateGetFromCache(ZoneList<Expression*>* args) {
   ASSERT_EQ(2, args->length());
@@ skipping 26 matching lines @@
   Result tmp = allocator()->Allocate();
   ASSERT(tmp.is_valid());
 
   DeferredSearchCache* deferred = new DeferredSearchCache(tmp.reg(),
                                                           cache.reg(),
                                                           key.reg());
 
   // tmp.reg() now holds finger offset as a smi.
   ASSERT(kSmiTag == 0 && kSmiTagSize == 1);
   __ mov(tmp.reg(), FieldOperand(cache.reg(),
-                    JSFunctionResultCache::kFingerOffset));
-  __ cmp(key.reg(), ArrayElement(cache.reg(), tmp.reg()));
+                                 JSFunctionResultCache::kFingerOffset));
+  __ cmp(key.reg(), FixedArrayElementOperand(cache.reg(), tmp.reg()));
   deferred->Branch(not_equal);
 
-  __ mov(tmp.reg(), ArrayElement(cache.reg(), tmp.reg(), 1));
+  __ mov(tmp.reg(), FixedArrayElementOperand(cache.reg(), tmp.reg(), 1));
 
   deferred->BindExit();
   frame_->Push(&tmp);
 }
 
 
 void CodeGenerator::GenerateNumberToString(ZoneList<Expression*>* args) {
   ASSERT_EQ(args->length(), 1);
 
   // Load the argument on the stack and call the stub.
@@ skipping 78 matching lines @@
   STATIC_ASSERT(kSmiTag == 0);
   STATIC_ASSERT(kSmiTagSize == 1);
 
   // Check that both indices are smis.
   __ mov(tmp2.reg(), index1.reg());
   __ or_(tmp2.reg(), Operand(index2.reg()));
   __ test(tmp2.reg(), Immediate(kSmiTagMask));
   deferred->Branch(not_zero);
 
   // Bring addresses into index1 and index2.
-  __ lea(index1.reg(), FieldOperand(tmp1.reg(),
-                                    index1.reg(),
-                                    times_half_pointer_size,  // index1 is Smi
-                                    FixedArray::kHeaderSize));
-  __ lea(index2.reg(), FieldOperand(tmp1.reg(),
-                                    index2.reg(),
-                                    times_half_pointer_size,  // index2 is Smi
-                                    FixedArray::kHeaderSize));
+  __ lea(index1.reg(), FixedArrayElementOperand(tmp1.reg(), index1.reg()));
+  __ lea(index2.reg(), FixedArrayElementOperand(tmp1.reg(), index2.reg()));
 
   // Swap elements.
   __ mov(object.reg(), Operand(index1.reg(), 0));
   __ mov(tmp2.reg(),   Operand(index2.reg(), 0));
   __ mov(Operand(index2.reg(), 0), object.reg());
   __ mov(Operand(index1.reg(), 0), tmp2.reg());
 
   Label done;
   __ InNewSpace(tmp1.reg(), tmp2.reg(), equal, &done);
   // Possible optimization: do a check that both values are Smis
@@ skipping 1852 matching lines @@
     // Bind the deferred code patch site to be able to locate the fixed
     // array map comparison.  When debugging, we patch this comparison to
     // always fail so that we will hit the IC call in the deferred code
     // which will allow the debugger to break for fast case stores.
     __ bind(deferred->patch_site());
     __ cmp(FieldOperand(tmp.reg(), HeapObject::kMapOffset),
            Immediate(Factory::fixed_array_map()));
     deferred->Branch(not_equal);
 
     // Store the value.
-    __ mov(Operand(tmp.reg(),
-                   key.reg(),
-                   times_2,
-                   FixedArray::kHeaderSize - kHeapObjectTag),
-           result.reg());
+    __ mov(FixedArrayElementOperand(tmp.reg(), key.reg()), result.reg());
     __ IncrementCounter(&Counters::keyed_store_inline, 1);
 
     deferred->BindExit();
   } else {
     result = frame()->CallKeyedStoreIC();
     // Make sure that we do not have a test instruction after the
     // call.  A test instruction after the call is used to
     // indicate that we have generated an inline version of the
     // keyed store.
     __ nop();
@@ skipping 281 matching lines @@
   // All sizes here are multiples of kPointerSize.
   int elements_size = (length_ > 0) ? FixedArray::SizeFor(length_) : 0;
   int size = JSArray::kSize + elements_size;
 
   // Load boilerplate object into ecx and check if we need to create a
   // boilerplate.
   Label slow_case;
   __ mov(ecx, Operand(esp, 3 * kPointerSize));
   __ mov(eax, Operand(esp, 2 * kPointerSize));
   ASSERT((kPointerSize == 4) && (kSmiTagSize == 1) && (kSmiTag == 0));
-  __ mov(ecx, FieldOperand(ecx, eax, times_2, FixedArray::kHeaderSize));
+  __ mov(ecx, CodeGenerator::FixedArrayElementOperand(ecx, eax));
   __ cmp(ecx, Factory::undefined_value());
   __ j(equal, &slow_case);
 
   // Allocate both the JS array and the elements array in one big
   // allocation. This avoids multiple limit checks.
   __ AllocateInNewSpace(size, eax, ebx, edx, &slow_case, TAG_OBJECT);
 
   // Copy the JS array part.
   for (int i = 0; i < JSArray::kSize; i += kPointerSize) {
     if ((i != JSArray::kElementsOffset) || (length_ == 0)) {
@@ skipping 4201 matching lines @@
 
   // Call the runtime; it returns -1 (less), 0 (equal), or 1 (greater)
   // tagged as a small integer.
   __ bind(&runtime);
   __ TailCallRuntime(Runtime::kStringCompare, 2, 1);
 }
 
 #undef __
 
 } }  // namespace v8::internal