OLD | NEW |
1 // Copyright 2006-2009 the V8 project authors. All rights reserved. | 1 // Copyright 2006-2009 the V8 project authors. All rights reserved. |
2 // Redistribution and use in source and binary forms, with or without | 2 // Redistribution and use in source and binary forms, with or without |
3 // modification, are permitted provided that the following conditions are | 3 // modification, are permitted provided that the following conditions are |
4 // met: | 4 // met: |
5 // | 5 // |
6 // * Redistributions of source code must retain the above copyright | 6 // * Redistributions of source code must retain the above copyright |
7 // notice, this list of conditions and the following disclaimer. | 7 // notice, this list of conditions and the following disclaimer. |
8 // * Redistributions in binary form must reproduce the above | 8 // * Redistributions in binary form must reproduce the above |
9 // copyright notice, this list of conditions and the following | 9 // copyright notice, this list of conditions and the following |
10 // disclaimer in the documentation and/or other materials provided | 10 // disclaimer in the documentation and/or other materials provided |
(...skipping 118 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
129 // Calculate the location of the elements array and set elements array member | 129 // Calculate the location of the elements array and set elements array member |
130 // of the JSArray. | 130 // of the JSArray. |
131 // result: JSObject | 131 // result: JSObject |
132 // scratch2: start of next object | 132 // scratch2: start of next object |
133 __ lea(scratch1, MemOperand(result, JSArray::kSize)); | 133 __ lea(scratch1, MemOperand(result, JSArray::kSize)); |
134 __ str(scratch1, FieldMemOperand(result, JSArray::kElementsOffset)); | 134 __ str(scratch1, FieldMemOperand(result, JSArray::kElementsOffset)); |
135 | 135 |
136 // Clear the heap tag on the elements array. | 136 // Clear the heap tag on the elements array. |
137 __ and_(scratch1, scratch1, Operand(~kHeapObjectTagMask)); | 137 __ and_(scratch1, scratch1, Operand(~kHeapObjectTagMask)); |
138 | 138 |
139 // Initialize the FixedArray and fill it with holes. FixedArray length is not | 139 // Initialize the FixedArray and fill it with holes. FixedArray length is |
140 // stored as a smi. | 140 // stored as a smi. |
141 // result: JSObject | 141 // result: JSObject |
142 // scratch1: elements array (untagged) | 142 // scratch1: elements array (untagged) |
143 // scratch2: start of next object | 143 // scratch2: start of next object |
144 __ LoadRoot(scratch3, Heap::kFixedArrayMapRootIndex); | 144 __ LoadRoot(scratch3, Heap::kFixedArrayMapRootIndex); |
145 ASSERT_EQ(0 * kPointerSize, FixedArray::kMapOffset); | 145 ASSERT_EQ(0 * kPointerSize, FixedArray::kMapOffset); |
146 __ str(scratch3, MemOperand(scratch1, kPointerSize, PostIndex)); | 146 __ str(scratch3, MemOperand(scratch1, kPointerSize, PostIndex)); |
147 __ mov(scratch3, Operand(initial_capacity)); | 147 __ mov(scratch3, Operand(Smi::FromInt(initial_capacity))); |
148 ASSERT_EQ(1 * kPointerSize, FixedArray::kLengthOffset); | 148 ASSERT_EQ(1 * kPointerSize, FixedArray::kLengthOffset); |
149 __ str(scratch3, MemOperand(scratch1, kPointerSize, PostIndex)); | 149 __ str(scratch3, MemOperand(scratch1, kPointerSize, PostIndex)); |
150 | 150 |
151 // Fill the FixedArray with the hole value. | 151 // Fill the FixedArray with the hole value. |
152 ASSERT_EQ(2 * kPointerSize, FixedArray::kHeaderSize); | 152 ASSERT_EQ(2 * kPointerSize, FixedArray::kHeaderSize); |
153 ASSERT(initial_capacity <= kLoopUnfoldLimit); | 153 ASSERT(initial_capacity <= kLoopUnfoldLimit); |
154 __ LoadRoot(scratch3, Heap::kTheHoleValueRootIndex); | 154 __ LoadRoot(scratch3, Heap::kTheHoleValueRootIndex); |
155 for (int i = 0; i < initial_capacity; i++) { | 155 for (int i = 0; i < initial_capacity; i++) { |
156 __ str(scratch3, MemOperand(scratch1, kPointerSize, PostIndex)); | 156 __ str(scratch3, MemOperand(scratch1, kPointerSize, PostIndex)); |
157 } | 157 } |
(...skipping 76 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
234 // result: JSObject | 234 // result: JSObject |
235 // array_size: size of array (smi) | 235 // array_size: size of array (smi) |
236 __ add(elements_array_storage, result, Operand(JSArray::kSize)); | 236 __ add(elements_array_storage, result, Operand(JSArray::kSize)); |
237 __ str(elements_array_storage, | 237 __ str(elements_array_storage, |
238 FieldMemOperand(result, JSArray::kElementsOffset)); | 238 FieldMemOperand(result, JSArray::kElementsOffset)); |
239 | 239 |
240 // Clear the heap tag on the elements array. | 240 // Clear the heap tag on the elements array. |
241 __ and_(elements_array_storage, | 241 __ and_(elements_array_storage, |
242 elements_array_storage, | 242 elements_array_storage, |
243 Operand(~kHeapObjectTagMask)); | 243 Operand(~kHeapObjectTagMask)); |
244 // Initialize the fixed array and fill it with holes. FixedArray length is not | 244 // Initialize the fixed array and fill it with holes. FixedArray length is |
245 // stored as a smi. | 245 // stored as a smi. |
246 // result: JSObject | 246 // result: JSObject |
247 // elements_array_storage: elements array (untagged) | 247 // elements_array_storage: elements array (untagged) |
248 // array_size: size of array (smi) | 248 // array_size: size of array (smi) |
249 ASSERT(kSmiTag == 0); | |
250 __ LoadRoot(scratch1, Heap::kFixedArrayMapRootIndex); | 249 __ LoadRoot(scratch1, Heap::kFixedArrayMapRootIndex); |
251 ASSERT_EQ(0 * kPointerSize, FixedArray::kMapOffset); | 250 ASSERT_EQ(0 * kPointerSize, FixedArray::kMapOffset); |
252 __ str(scratch1, MemOperand(elements_array_storage, kPointerSize, PostIndex)); | 251 __ str(scratch1, MemOperand(elements_array_storage, kPointerSize, PostIndex)); |
253 // Convert array_size from smi to value. | 252 ASSERT(kSmiTag == 0); |
254 __ mov(array_size, | |
255 Operand(array_size, ASR, kSmiTagSize)); | |
256 __ tst(array_size, array_size); | 253 __ tst(array_size, array_size); |
257 // Length of the FixedArray is the number of pre-allocated elements if | 254 // Length of the FixedArray is the number of pre-allocated elements if |
258 // the actual JSArray has length 0 and the size of the JSArray for non-empty | 255 // the actual JSArray has length 0 and the size of the JSArray for non-empty |
259 // JSArrays. The length of a FixedArray is not stored as a smi. | 256 // JSArrays. The length of a FixedArray is stored as a smi. |
260 __ mov(array_size, Operand(JSArray::kPreallocatedArrayElements), LeaveCC, eq); | 257 __ mov(array_size, |
| 258 Operand(Smi::FromInt(JSArray::kPreallocatedArrayElements)), |
| 259 LeaveCC, |
| 260 eq); |
261 ASSERT_EQ(1 * kPointerSize, FixedArray::kLengthOffset); | 261 ASSERT_EQ(1 * kPointerSize, FixedArray::kLengthOffset); |
262 __ str(array_size, | 262 __ str(array_size, |
263 MemOperand(elements_array_storage, kPointerSize, PostIndex)); | 263 MemOperand(elements_array_storage, kPointerSize, PostIndex)); |
264 | 264 |
265 // Calculate elements array and elements array end. | 265 // Calculate elements array and elements array end. |
266 // result: JSObject | 266 // result: JSObject |
267 // elements_array_storage: elements array element storage | 267 // elements_array_storage: elements array element storage |
268 // array_size: size of elements array | 268 // array_size: smi-tagged size of elements array |
| 269 ASSERT(kSmiTag == 0 && kSmiTagSize < kPointerSizeLog2); |
269 __ add(elements_array_end, | 270 __ add(elements_array_end, |
270 elements_array_storage, | 271 elements_array_storage, |
271 Operand(array_size, LSL, kPointerSizeLog2)); | 272 Operand(array_size, LSL, kPointerSizeLog2 - kSmiTagSize)); |
272 | 273 |
273 // Fill the allocated FixedArray with the hole value if requested. | 274 // Fill the allocated FixedArray with the hole value if requested. |
274 // result: JSObject | 275 // result: JSObject |
275 // elements_array_storage: elements array element storage | 276 // elements_array_storage: elements array element storage |
276 // elements_array_end: start of next object | 277 // elements_array_end: start of next object |
277 if (fill_with_hole) { | 278 if (fill_with_hole) { |
278 Label loop, entry; | 279 Label loop, entry; |
279 __ LoadRoot(scratch1, Heap::kTheHoleValueRootIndex); | 280 __ LoadRoot(scratch1, Heap::kTheHoleValueRootIndex); |
280 __ jmp(&entry); | 281 __ jmp(&entry); |
281 __ bind(&loop); | 282 __ bind(&loop); |
(...skipping 252 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
534 ExternalReference debug_step_in_fp = | 535 ExternalReference debug_step_in_fp = |
535 ExternalReference::debug_step_in_fp_address(); | 536 ExternalReference::debug_step_in_fp_address(); |
536 __ mov(r2, Operand(debug_step_in_fp)); | 537 __ mov(r2, Operand(debug_step_in_fp)); |
537 __ ldr(r2, MemOperand(r2)); | 538 __ ldr(r2, MemOperand(r2)); |
538 __ tst(r2, r2); | 539 __ tst(r2, r2); |
539 __ b(nz, &rt_call); | 540 __ b(nz, &rt_call); |
540 #endif | 541 #endif |
541 | 542 |
542 // Load the initial map and verify that it is in fact a map. | 543 // Load the initial map and verify that it is in fact a map. |
543 // r1: constructor function | 544 // r1: constructor function |
544 // r7: undefined | 545 // r7: undefined value |
545 __ ldr(r2, FieldMemOperand(r1, JSFunction::kPrototypeOrInitialMapOffset)); | 546 __ ldr(r2, FieldMemOperand(r1, JSFunction::kPrototypeOrInitialMapOffset)); |
546 __ tst(r2, Operand(kSmiTagMask)); | 547 __ tst(r2, Operand(kSmiTagMask)); |
547 __ b(eq, &rt_call); | 548 __ b(eq, &rt_call); |
548 __ CompareObjectType(r2, r3, r4, MAP_TYPE); | 549 __ CompareObjectType(r2, r3, r4, MAP_TYPE); |
549 __ b(ne, &rt_call); | 550 __ b(ne, &rt_call); |
550 | 551 |
551 // Check that the constructor is not constructing a JSFunction (see comments | 552 // Check that the constructor is not constructing a JSFunction (see comments |
552 // in Runtime_NewObject in runtime.cc). In which case the initial map's | 553 // in Runtime_NewObject in runtime.cc). In which case the initial map's |
553 // instance type would be JS_FUNCTION_TYPE. | 554 // instance type would be JS_FUNCTION_TYPE. |
554 // r1: constructor function | 555 // r1: constructor function |
555 // r2: initial map | 556 // r2: initial map |
556 // r7: undefined | 557 // r7: undefined value |
557 __ CompareInstanceType(r2, r3, JS_FUNCTION_TYPE); | 558 __ CompareInstanceType(r2, r3, JS_FUNCTION_TYPE); |
558 __ b(eq, &rt_call); | 559 __ b(eq, &rt_call); |
559 | 560 |
560 // Now allocate the JSObject on the heap. | 561 // Now allocate the JSObject on the heap. |
561 // r1: constructor function | 562 // r1: constructor function |
562 // r2: initial map | 563 // r2: initial map |
563 // r7: undefined | 564 // r7: undefined value |
564 __ ldrb(r3, FieldMemOperand(r2, Map::kInstanceSizeOffset)); | 565 __ ldrb(r3, FieldMemOperand(r2, Map::kInstanceSizeOffset)); |
565 __ AllocateInNewSpace(r3, r4, r5, r6, &rt_call, SIZE_IN_WORDS); | 566 __ AllocateInNewSpace(r3, r4, r5, r6, &rt_call, SIZE_IN_WORDS); |
566 | 567 |
567 // Allocated the JSObject, now initialize the fields. Map is set to initial | 568 // Allocated the JSObject, now initialize the fields. Map is set to initial |
568 // map and properties and elements are set to empty fixed array. | 569 // map and properties and elements are set to empty fixed array. |
569 // r1: constructor function | 570 // r1: constructor function |
570 // r2: initial map | 571 // r2: initial map |
571 // r3: object size | 572 // r3: object size |
572 // r4: JSObject (not tagged) | 573 // r4: JSObject (not tagged) |
573 // r7: undefined | 574 // r7: undefined value |
574 __ LoadRoot(r6, Heap::kEmptyFixedArrayRootIndex); | 575 __ LoadRoot(r6, Heap::kEmptyFixedArrayRootIndex); |
575 __ mov(r5, r4); | 576 __ mov(r5, r4); |
576 ASSERT_EQ(0 * kPointerSize, JSObject::kMapOffset); | 577 ASSERT_EQ(0 * kPointerSize, JSObject::kMapOffset); |
577 __ str(r2, MemOperand(r5, kPointerSize, PostIndex)); | 578 __ str(r2, MemOperand(r5, kPointerSize, PostIndex)); |
578 ASSERT_EQ(1 * kPointerSize, JSObject::kPropertiesOffset); | 579 ASSERT_EQ(1 * kPointerSize, JSObject::kPropertiesOffset); |
579 __ str(r6, MemOperand(r5, kPointerSize, PostIndex)); | 580 __ str(r6, MemOperand(r5, kPointerSize, PostIndex)); |
580 ASSERT_EQ(2 * kPointerSize, JSObject::kElementsOffset); | 581 ASSERT_EQ(2 * kPointerSize, JSObject::kElementsOffset); |
581 __ str(r6, MemOperand(r5, kPointerSize, PostIndex)); | 582 __ str(r6, MemOperand(r5, kPointerSize, PostIndex)); |
582 | 583 |
583 // Fill all the in-object properties with undefined. | 584 // Fill all the in-object properties with undefined. |
584 // r1: constructor function | 585 // r1: constructor function |
585 // r2: initial map | 586 // r2: initial map |
586 // r3: object size (in words) | 587 // r3: object size (in words) |
587 // r4: JSObject (not tagged) | 588 // r4: JSObject (not tagged) |
588 // r5: First in-object property of JSObject (not tagged) | 589 // r5: First in-object property of JSObject (not tagged) |
589 // r7: undefined | 590 // r7: undefined value |
590 __ add(r6, r4, Operand(r3, LSL, kPointerSizeLog2)); // End of object. | 591 __ add(r6, r4, Operand(r3, LSL, kPointerSizeLog2)); // End of object. |
591 ASSERT_EQ(3 * kPointerSize, JSObject::kHeaderSize); | 592 ASSERT_EQ(3 * kPointerSize, JSObject::kHeaderSize); |
592 { Label loop, entry; | 593 { Label loop, entry; |
593 __ b(&entry); | 594 __ b(&entry); |
594 __ bind(&loop); | 595 __ bind(&loop); |
595 __ str(r7, MemOperand(r5, kPointerSize, PostIndex)); | 596 __ str(r7, MemOperand(r5, kPointerSize, PostIndex)); |
596 __ bind(&entry); | 597 __ bind(&entry); |
597 __ cmp(r5, r6); | 598 __ cmp(r5, r6); |
598 __ b(lt, &loop); | 599 __ b(lt, &loop); |
599 } | 600 } |
600 | 601 |
601 // Add the object tag to make the JSObject real, so that we can continue and | 602 // Add the object tag to make the JSObject real, so that we can continue and |
602 // jump into the continuation code at any time from now on. Any failures | 603 // jump into the continuation code at any time from now on. Any failures |
603 // need to undo the allocation, so that the heap is in a consistent state | 604 // need to undo the allocation, so that the heap is in a consistent state |
604 // and verifiable. | 605 // and verifiable. |
605 __ add(r4, r4, Operand(kHeapObjectTag)); | 606 __ add(r4, r4, Operand(kHeapObjectTag)); |
606 | 607 |
607 // Check if a non-empty properties array is needed. Continue with allocated | 608 // Check if a non-empty properties array is needed. Continue with allocated |
608 // object if not fall through to runtime call if it is. | 609 // object if not fall through to runtime call if it is. |
609 // r1: constructor function | 610 // r1: constructor function |
610 // r4: JSObject | 611 // r4: JSObject |
611 // r5: start of next object (not tagged) | 612 // r5: start of next object (not tagged) |
612 // r7: undefined | 613 // r7: undefined value |
613 __ ldrb(r3, FieldMemOperand(r2, Map::kUnusedPropertyFieldsOffset)); | 614 __ ldrb(r3, FieldMemOperand(r2, Map::kUnusedPropertyFieldsOffset)); |
614 // The field instance sizes contains both pre-allocated property fields and | 615 // The field instance sizes contains both pre-allocated property fields and |
615 // in-object properties. | 616 // in-object properties. |
616 __ ldr(r0, FieldMemOperand(r2, Map::kInstanceSizesOffset)); | 617 __ ldr(r0, FieldMemOperand(r2, Map::kInstanceSizesOffset)); |
617 __ and_(r6, | 618 __ and_(r6, |
618 r0, | 619 r0, |
619 Operand(0x000000FF << Map::kPreAllocatedPropertyFieldsByte * 8)); | 620 Operand(0x000000FF << Map::kPreAllocatedPropertyFieldsByte * 8)); |
620 __ add(r3, r3, Operand(r6, LSR, Map::kPreAllocatedPropertyFieldsByte * 8)); | 621 __ add(r3, r3, Operand(r6, LSR, Map::kPreAllocatedPropertyFieldsByte * 8)); |
621 __ and_(r6, r0, Operand(0x000000FF << Map::kInObjectPropertiesByte * 8)); | 622 __ and_(r6, r0, Operand(0x000000FF << Map::kInObjectPropertiesByte * 8)); |
622 __ sub(r3, r3, Operand(r6, LSR, Map::kInObjectPropertiesByte * 8), SetCC); | 623 __ sub(r3, r3, Operand(r6, LSR, Map::kInObjectPropertiesByte * 8), SetCC); |
623 | 624 |
624 // Done if no extra properties are to be allocated. | 625 // Done if no extra properties are to be allocated. |
625 __ b(eq, &allocated); | 626 __ b(eq, &allocated); |
626 __ Assert(pl, "Property allocation count failed."); | 627 __ Assert(pl, "Property allocation count failed."); |
627 | 628 |
628 // Scale the number of elements by pointer size and add the header for | 629 // Scale the number of elements by pointer size and add the header for |
629 // FixedArrays to the start of the next object calculation from above. | 630 // FixedArrays to the start of the next object calculation from above. |
630 // r1: constructor | 631 // r1: constructor |
631 // r3: number of elements in properties array | 632 // r3: number of elements in properties array |
632 // r4: JSObject | 633 // r4: JSObject |
633 // r5: start of next object | 634 // r5: start of next object |
634 // r7: undefined | 635 // r7: undefined value |
635 __ add(r0, r3, Operand(FixedArray::kHeaderSize / kPointerSize)); | 636 __ add(r0, r3, Operand(FixedArray::kHeaderSize / kPointerSize)); |
636 __ AllocateInNewSpace( | 637 __ AllocateInNewSpace( |
637 r0, | 638 r0, |
638 r5, | 639 r5, |
639 r6, | 640 r6, |
640 r2, | 641 r2, |
641 &undo_allocation, | 642 &undo_allocation, |
642 static_cast<AllocationFlags>(RESULT_CONTAINS_TOP | SIZE_IN_WORDS)); | 643 static_cast<AllocationFlags>(RESULT_CONTAINS_TOP | SIZE_IN_WORDS)); |
643 | 644 |
644 // Initialize the FixedArray. | 645 // Initialize the FixedArray. |
645 // r1: constructor | 646 // r1: constructor |
646 // r3: number of elements in properties array | 647 // r3: number of elements in properties array |
647 // r4: JSObject | 648 // r4: JSObject |
648 // r5: FixedArray (not tagged) | 649 // r5: FixedArray (not tagged) |
649 // r7: undefined | 650 // r7: undefined value |
650 __ LoadRoot(r6, Heap::kFixedArrayMapRootIndex); | 651 __ LoadRoot(r6, Heap::kFixedArrayMapRootIndex); |
651 __ mov(r2, r5); | 652 __ mov(r2, r5); |
652 ASSERT_EQ(0 * kPointerSize, JSObject::kMapOffset); | 653 ASSERT_EQ(0 * kPointerSize, JSObject::kMapOffset); |
653 __ str(r6, MemOperand(r2, kPointerSize, PostIndex)); | 654 __ str(r6, MemOperand(r2, kPointerSize, PostIndex)); |
654 ASSERT_EQ(1 * kPointerSize, Array::kLengthOffset); | 655 ASSERT_EQ(1 * kPointerSize, FixedArray::kLengthOffset); |
655 __ str(r3, MemOperand(r2, kPointerSize, PostIndex)); | 656 __ mov(r0, Operand(r3, LSL, kSmiTagSize)); |
| 657 __ str(r0, MemOperand(r2, kPointerSize, PostIndex)); |
656 | 658 |
657 // Initialize the fields to undefined. | 659 // Initialize the fields to undefined. |
658 // r1: constructor function | 660 // r1: constructor function |
659 // r2: First element of FixedArray (not tagged) | 661 // r2: First element of FixedArray (not tagged) |
660 // r3: number of elements in properties array | 662 // r3: number of elements in properties array |
661 // r4: JSObject | 663 // r4: JSObject |
662 // r5: FixedArray (not tagged) | 664 // r5: FixedArray (not tagged) |
663 // r7: undefined | 665 // r7: undefined |
664 __ add(r6, r2, Operand(r3, LSL, kPointerSizeLog2)); // End of object. | 666 __ add(r6, r2, Operand(r3, LSL, kPointerSizeLog2)); // End of object. |
665 ASSERT_EQ(2 * kPointerSize, FixedArray::kHeaderSize); | 667 ASSERT_EQ(2 * kPointerSize, FixedArray::kHeaderSize); |
(...skipping 372 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1038 } | 1040 } |
1039 | 1041 |
1040 // 5b. Get the code to call from the function and check that the number of | 1042 // 5b. Get the code to call from the function and check that the number of |
1041 // expected arguments matches what we're providing. If so, jump | 1043 // expected arguments matches what we're providing. If so, jump |
1042 // (tail-call) to the code in register edx without checking arguments. | 1044 // (tail-call) to the code in register edx without checking arguments. |
1043 // r0: actual number of arguments | 1045 // r0: actual number of arguments |
1044 // r1: function | 1046 // r1: function |
1045 __ ldr(r3, FieldMemOperand(r1, JSFunction::kSharedFunctionInfoOffset)); | 1047 __ ldr(r3, FieldMemOperand(r1, JSFunction::kSharedFunctionInfoOffset)); |
1046 __ ldr(r2, | 1048 __ ldr(r2, |
1047 FieldMemOperand(r3, SharedFunctionInfo::kFormalParameterCountOffset)); | 1049 FieldMemOperand(r3, SharedFunctionInfo::kFormalParameterCountOffset)); |
| 1050 __ mov(r2, Operand(r2, ASR, kSmiTagSize)); |
1048 __ ldr(r3, FieldMemOperand(r3, SharedFunctionInfo::kCodeOffset)); | 1051 __ ldr(r3, FieldMemOperand(r3, SharedFunctionInfo::kCodeOffset)); |
1049 __ add(r3, r3, Operand(Code::kHeaderSize - kHeapObjectTag)); | 1052 __ add(r3, r3, Operand(Code::kHeaderSize - kHeapObjectTag)); |
1050 __ cmp(r2, r0); // Check formal and actual parameter counts. | 1053 __ cmp(r2, r0); // Check formal and actual parameter counts. |
1051 __ Jump(Handle<Code>(builtin(ArgumentsAdaptorTrampoline)), | 1054 __ Jump(Handle<Code>(builtin(ArgumentsAdaptorTrampoline)), |
1052 RelocInfo::CODE_TARGET, ne); | 1055 RelocInfo::CODE_TARGET, ne); |
1053 | 1056 |
1054 ParameterCount expected(0); | 1057 ParameterCount expected(0); |
1055 __ InvokeCode(r3, expected, expected, JUMP_FUNCTION); | 1058 __ InvokeCode(r3, expected, expected, JUMP_FUNCTION); |
1056 } | 1059 } |
1057 | 1060 |
(...skipping 246 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1304 // Dont adapt arguments. | 1307 // Dont adapt arguments. |
1305 // ------------------------------------------- | 1308 // ------------------------------------------- |
1306 __ bind(&dont_adapt_arguments); | 1309 __ bind(&dont_adapt_arguments); |
1307 __ Jump(r3); | 1310 __ Jump(r3); |
1308 } | 1311 } |
1309 | 1312 |
1310 | 1313 |
1311 #undef __ | 1314 #undef __ |
1312 | 1315 |
1313 } } // namespace v8::internal | 1316 } } // namespace v8::internal |
OLD | NEW |