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

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

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

Powered by Google App Engine
This is Rietveld 408576698