← Back to branch summary

~ubuntu-branches/ubuntu/precise/nodejs/precise

« back to all changes in this revision

Viewing changes to deps/v8/src/arm/builtins-arm.cc

  • Committer: Bazaar Package Importer
  • Author(s): Jérémy Lal
  • Date: 2010-08-20 11:49:04 UTC
  • mfrom: (7.1.6 sid)
  • Revision ID: james.westby@ubuntu.com-20100820114904-lz22w6fkth7yh179
Tags: 0.2.0-1
New upstream release

Show diffs side-by-side

added added

removed removed

Lines of Context:
deps/v8/src/arm/builtins-arm.cc
136
136
  __ str(scratch1, FieldMemOperand(result, JSArray::kElementsOffset));
137
137
 
138
138
  // Clear the heap tag on the elements array.
139
 
  __ and_(scratch1, scratch1, Operand(~kHeapObjectTagMask));
 
139
  ASSERT(kSmiTag == 0);
 
140
  __ sub(scratch1, scratch1, Operand(kHeapObjectTag));
140
141
 
141
 
  // Initialize the FixedArray and fill it with holes. FixedArray length is not
 
142
  // Initialize the FixedArray and fill it with holes. FixedArray length is
142
143
  // stored as a smi.
143
144
  // result: JSObject
144
145
  // scratch1: elements array (untagged)
146
147
  __ LoadRoot(scratch3, Heap::kFixedArrayMapRootIndex);
147
148
  ASSERT_EQ(0 * kPointerSize, FixedArray::kMapOffset);
148
149
  __ str(scratch3, MemOperand(scratch1, kPointerSize, PostIndex));
149
 
  __ mov(scratch3,  Operand(initial_capacity));
 
150
  __ mov(scratch3,  Operand(Smi::FromInt(initial_capacity)));
150
151
  ASSERT_EQ(1 * kPointerSize, FixedArray::kLengthOffset);
151
152
  __ str(scratch3, MemOperand(scratch1, kPointerSize, PostIndex));
152
153
 
240
241
         FieldMemOperand(result, JSArray::kElementsOffset));
241
242
 
242
243
  // Clear the heap tag on the elements array.
243
 
  __ and_(elements_array_storage,
244
 
          elements_array_storage,
245
 
          Operand(~kHeapObjectTagMask));
246
 
  // Initialize the fixed array and fill it with holes. FixedArray length is not
 
244
  ASSERT(kSmiTag == 0);
 
245
  __ sub(elements_array_storage,
 
246
         elements_array_storage,
 
247
         Operand(kHeapObjectTag));
 
248
  // Initialize the fixed array and fill it with holes. FixedArray length is
247
249
  // stored as a smi.
248
250
  // result: JSObject
249
251
  // elements_array_storage: elements array (untagged)
250
252
  // array_size: size of array (smi)
251
 
  ASSERT(kSmiTag == 0);
252
253
  __ LoadRoot(scratch1, Heap::kFixedArrayMapRootIndex);
253
254
  ASSERT_EQ(0 * kPointerSize, FixedArray::kMapOffset);
254
255
  __ str(scratch1, MemOperand(elements_array_storage, kPointerSize, PostIndex));
255
 
  // Convert array_size from smi to value.
256
 
  __ mov(array_size,
257
 
         Operand(array_size, ASR, kSmiTagSize));
 
256
  ASSERT(kSmiTag == 0);
258
257
  __ tst(array_size, array_size);
259
258
  // Length of the FixedArray is the number of pre-allocated elements if
260
259
  // the actual JSArray has length 0 and the size of the JSArray for non-empty
261
 
  // JSArrays. The length of a FixedArray is not stored as a smi.
262
 
  __ mov(array_size, Operand(JSArray::kPreallocatedArrayElements), LeaveCC, eq);
 
260
  // JSArrays. The length of a FixedArray is stored as a smi.
 
261
  __ mov(array_size,
 
262
         Operand(Smi::FromInt(JSArray::kPreallocatedArrayElements)),
 
263
         LeaveCC,
 
264
         eq);
263
265
  ASSERT_EQ(1 * kPointerSize, FixedArray::kLengthOffset);
264
266
  __ str(array_size,
265
267
         MemOperand(elements_array_storage, kPointerSize, PostIndex));
267
269
  // Calculate elements array and elements array end.
268
270
  // result: JSObject
269
271
  // elements_array_storage: elements array element storage
270
 
  // array_size: size of elements array
 
272
  // array_size: smi-tagged size of elements array
 
273
  ASSERT(kSmiTag == 0 && kSmiTagSize < kPointerSizeLog2);
271
274
  __ add(elements_array_end,
272
275
         elements_array_storage,
273
 
         Operand(array_size, LSL, kPointerSizeLog2));
 
276
         Operand(array_size, LSL, kPointerSizeLog2 - kSmiTagSize));
274
277
 
275
278
  // Fill the allocated FixedArray with the hole value if requested.
276
279
  // result: JSObject
543
546
 
544
547
    // Load the initial map and verify that it is in fact a map.
545
548
    // r1: constructor function
546
 
    // r7: undefined
 
549
    // r7: undefined value
547
550
    __ ldr(r2, FieldMemOperand(r1, JSFunction::kPrototypeOrInitialMapOffset));
548
551
    __ tst(r2, Operand(kSmiTagMask));
549
552
    __ b(eq, &rt_call);
555
558
    // instance type would be JS_FUNCTION_TYPE.
556
559
    // r1: constructor function
557
560
    // r2: initial map
558
 
    // r7: undefined
 
561
    // r7: undefined value
559
562
    __ CompareInstanceType(r2, r3, JS_FUNCTION_TYPE);
560
563
    __ b(eq, &rt_call);
561
564
 
562
565
    // Now allocate the JSObject on the heap.
563
566
    // r1: constructor function
564
567
    // r2: initial map
565
 
    // r7: undefined
 
568
    // r7: undefined value
566
569
    __ ldrb(r3, FieldMemOperand(r2, Map::kInstanceSizeOffset));
567
570
    __ AllocateInNewSpace(r3, r4, r5, r6, &rt_call, SIZE_IN_WORDS);
568
571
 
572
575
    // r2: initial map
573
576
    // r3: object size
574
577
    // r4: JSObject (not tagged)
575
 
    // r7: undefined
 
578
    // r7: undefined value
576
579
    __ LoadRoot(r6, Heap::kEmptyFixedArrayRootIndex);
577
580
    __ mov(r5, r4);
578
581
    ASSERT_EQ(0 * kPointerSize, JSObject::kMapOffset);
588
591
    // r3: object size (in words)
589
592
    // r4: JSObject (not tagged)
590
593
    // r5: First in-object property of JSObject (not tagged)
591
 
    // r7: undefined
 
594
    // r7: undefined value
592
595
    __ add(r6, r4, Operand(r3, LSL, kPointerSizeLog2));  // End of object.
593
596
    ASSERT_EQ(3 * kPointerSize, JSObject::kHeaderSize);
594
597
    { Label loop, entry;
611
614
    // r1: constructor function
612
615
    // r4: JSObject
613
616
    // r5: start of next object (not tagged)
614
 
    // r7: undefined
 
617
    // r7: undefined value
615
618
    __ ldrb(r3, FieldMemOperand(r2, Map::kUnusedPropertyFieldsOffset));
616
619
    // The field instance sizes contains both pre-allocated property fields and
617
620
    // in-object properties.
618
621
    __ ldr(r0, FieldMemOperand(r2, Map::kInstanceSizesOffset));
619
 
    __ and_(r6,
620
 
            r0,
621
 
            Operand(0x000000FF << Map::kPreAllocatedPropertyFieldsByte * 8));
622
 
    __ add(r3, r3, Operand(r6, LSR, Map::kPreAllocatedPropertyFieldsByte * 8));
623
 
    __ and_(r6, r0, Operand(0x000000FF << Map::kInObjectPropertiesByte * 8));
624
 
    __ sub(r3, r3, Operand(r6, LSR, Map::kInObjectPropertiesByte * 8), SetCC);
 
622
    __ Ubfx(r6, r0, Map::kPreAllocatedPropertyFieldsByte * 8, 8);
 
623
    __ add(r3, r3, Operand(r6));
 
624
    __ Ubfx(r6, r0, Map::kInObjectPropertiesByte * 8, 8);
 
625
    __ sub(r3, r3, Operand(r6), SetCC);
625
626
 
626
627
    // Done if no extra properties are to be allocated.
627
628
    __ b(eq, &allocated);
633
634
    // r3: number of elements in properties array
634
635
    // r4: JSObject
635
636
    // r5: start of next object
636
 
    // r7: undefined
 
637
    // r7: undefined value
637
638
    __ add(r0, r3, Operand(FixedArray::kHeaderSize / kPointerSize));
638
639
    __ AllocateInNewSpace(
639
640
        r0,
648
649
    // r3: number of elements in properties array
649
650
    // r4: JSObject
650
651
    // r5: FixedArray (not tagged)
651
 
    // r7: undefined
 
652
    // r7: undefined value
652
653
    __ LoadRoot(r6, Heap::kFixedArrayMapRootIndex);
653
654
    __ mov(r2, r5);
654
655
    ASSERT_EQ(0 * kPointerSize, JSObject::kMapOffset);
655
656
    __ str(r6, MemOperand(r2, kPointerSize, PostIndex));
656
 
    ASSERT_EQ(1 * kPointerSize, Array::kLengthOffset);
657
 
    __ str(r3, MemOperand(r2, kPointerSize, PostIndex));
 
657
    ASSERT_EQ(1 * kPointerSize, FixedArray::kLengthOffset);
 
658
    __ mov(r0, Operand(r3, LSL, kSmiTagSize));
 
659
    __ str(r0, MemOperand(r2, kPointerSize, PostIndex));
658
660
 
659
661
    // Initialize the fields to undefined.
660
662
    // r1: constructor function
909
911
}
910
912
 
911
913
 
 
914
void Builtins::Generate_LazyCompile(MacroAssembler* masm) {
 
915
  // Enter an internal frame.
 
916
  __ EnterInternalFrame();
 
917
 
 
918
  // Preserve the function.
 
919
  __ push(r1);
 
920
 
 
921
  // Push the function on the stack as the argument to the runtime function.
 
922
  __ push(r1);
 
923
  __ CallRuntime(Runtime::kLazyCompile, 1);
 
924
  // Calculate the entry point.
 
925
  __ add(r2, r0, Operand(Code::kHeaderSize - kHeapObjectTag));
 
926
  // Restore saved function.
 
927
  __ pop(r1);
 
928
 
 
929
  // Tear down temporary frame.
 
930
  __ LeaveInternalFrame();
 
931
 
 
932
  // Do a tail-call of the compiled function.
 
933
  __ Jump(r2);
 
934
}
 
935
 
 
936
 
912
937
void Builtins::Generate_FunctionCall(MacroAssembler* masm) {
913
938
  // 1. Make sure we have at least one argument.
914
939
  // r0: actual number of arguments
1047
1072
  __ ldr(r3, FieldMemOperand(r1, JSFunction::kSharedFunctionInfoOffset));
1048
1073
  __ ldr(r2,
1049
1074
         FieldMemOperand(r3, SharedFunctionInfo::kFormalParameterCountOffset));
1050
 
  __ ldr(r3, FieldMemOperand(r3, SharedFunctionInfo::kCodeOffset));
 
1075
  __ mov(r2, Operand(r2, ASR, kSmiTagSize));
 
1076
  __ ldr(r3, FieldMemOperand(r1, JSFunction::kCodeOffset));
1051
1077
  __ add(r3, r3, Operand(Code::kHeaderSize - kHeapObjectTag));
1052
1078
  __ cmp(r2, r0);  // Check formal and actual parameter counts.
1053
1079
  __ Jump(Handle<Code>(builtin(ArgumentsAdaptorTrampoline)),