Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(395)

Side by Side Diff: src/arm/builtins-arm.cc

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

Powered by Google App Engine
This is Rietveld 408576698