builtins-arm.cc revision 9dcf7e2f83591d471e88bf7d230651900b8e424b
1// Copyright 2006-2009 the V8 project authors. All rights reserved. 2// Redistribution and use in source and binary forms, with or without 3// modification, are permitted provided that the following conditions are 4// met: 5// 6// * Redistributions of source code must retain the above copyright 7// notice, this list of conditions and the following disclaimer. 8// * Redistributions in binary form must reproduce the above 9// copyright notice, this list of conditions and the following 10// disclaimer in the documentation and/or other materials provided 11// with the distribution. 12// * Neither the name of Google Inc. nor the names of its 13// contributors may be used to endorse or promote products derived 14// from this software without specific prior written permission. 15// 16// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 17// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 18// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 19// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 20// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 21// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 22// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 26// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 28#include "v8.h" 29 30#if defined(V8_TARGET_ARCH_ARM) 31 32#include "codegen-inl.h" 33#include "debug.h" 34#include "runtime.h" 35 36namespace v8 { 37namespace internal { 38 39 40#define __ ACCESS_MASM(masm) 41 42 43void Builtins::Generate_Adaptor(MacroAssembler* masm, 44 CFunctionId id, 45 BuiltinExtraArguments extra_args) { 46 // ----------- S t a t e ------------- 47 // -- r0 : number of arguments excluding receiver 48 // -- r1 : called function (only guaranteed when 49 // extra_args requires it) 50 // -- cp : context 51 // -- sp[0] : last argument 52 // -- ... 53 // -- sp[4 * (argc - 1)] : first argument (argc == r0) 54 // -- sp[4 * argc] : receiver 55 // ----------------------------------- 56 57 // Insert extra arguments. 58 int num_extra_args = 0; 59 if (extra_args == NEEDS_CALLED_FUNCTION) { 60 num_extra_args = 1; 61 __ push(r1); 62 } else { 63 ASSERT(extra_args == NO_EXTRA_ARGUMENTS); 64 } 65 66 // JumpToExternalReference expects r0 to contain the number of arguments 67 // including the receiver and the extra arguments. 68 __ add(r0, r0, Operand(num_extra_args + 1)); 69 __ JumpToExternalReference(ExternalReference(id)); 70} 71 72 73// Load the built-in Array function from the current context. 74static void GenerateLoadArrayFunction(MacroAssembler* masm, Register result) { 75 // Load the global context. 76 77 __ ldr(result, MemOperand(cp, Context::SlotOffset(Context::GLOBAL_INDEX))); 78 __ ldr(result, 79 FieldMemOperand(result, GlobalObject::kGlobalContextOffset)); 80 // Load the Array function from the global context. 81 __ ldr(result, 82 MemOperand(result, 83 Context::SlotOffset(Context::ARRAY_FUNCTION_INDEX))); 84} 85 86 87// This constant has the same value as JSArray::kPreallocatedArrayElements and 88// if JSArray::kPreallocatedArrayElements is changed handling of loop unfolding 89// below should be reconsidered. 90static const int kLoopUnfoldLimit = 4; 91 92 93// Allocate an empty JSArray. The allocated array is put into the result 94// register. An elements backing store is allocated with size initial_capacity 95// and filled with the hole values. 96static void AllocateEmptyJSArray(MacroAssembler* masm, 97 Register array_function, 98 Register result, 99 Register scratch1, 100 Register scratch2, 101 Register scratch3, 102 int initial_capacity, 103 Label* gc_required) { 104 ASSERT(initial_capacity > 0); 105 // Load the initial map from the array function. 106 __ ldr(scratch1, FieldMemOperand(array_function, 107 JSFunction::kPrototypeOrInitialMapOffset)); 108 109 // Allocate the JSArray object together with space for a fixed array with the 110 // requested elements. 111 int size = JSArray::kSize + FixedArray::SizeFor(initial_capacity); 112 __ AllocateInNewSpace(size, 113 result, 114 scratch2, 115 scratch3, 116 gc_required, 117 TAG_OBJECT); 118 119 // Allocated the JSArray. Now initialize the fields except for the elements 120 // array. 121 // result: JSObject 122 // scratch1: initial map 123 // scratch2: start of next object 124 __ str(scratch1, FieldMemOperand(result, JSObject::kMapOffset)); 125 __ LoadRoot(scratch1, Heap::kEmptyFixedArrayRootIndex); 126 __ str(scratch1, FieldMemOperand(result, JSArray::kPropertiesOffset)); 127 // Field JSArray::kElementsOffset is initialized later. 128 __ mov(scratch3, Operand(0)); 129 __ str(scratch3, FieldMemOperand(result, JSArray::kLengthOffset)); 130 131 // Calculate the location of the elements array and set elements array member 132 // of the JSArray. 133 // result: JSObject 134 // scratch2: start of next object 135 __ add(scratch1, result, Operand(JSArray::kSize)); 136 __ str(scratch1, FieldMemOperand(result, JSArray::kElementsOffset)); 137 138 // Clear the heap tag on the elements array. 139 ASSERT(kSmiTag == 0); 140 __ sub(scratch1, scratch1, Operand(kHeapObjectTag)); 141 142 // Initialize the FixedArray and fill it with holes. FixedArray length is 143 // stored as a smi. 144 // result: JSObject 145 // scratch1: elements array (untagged) 146 // scratch2: start of next object 147 __ LoadRoot(scratch3, Heap::kFixedArrayMapRootIndex); 148 ASSERT_EQ(0 * kPointerSize, FixedArray::kMapOffset); 149 __ str(scratch3, MemOperand(scratch1, kPointerSize, PostIndex)); 150 __ mov(scratch3, Operand(Smi::FromInt(initial_capacity))); 151 ASSERT_EQ(1 * kPointerSize, FixedArray::kLengthOffset); 152 __ str(scratch3, MemOperand(scratch1, kPointerSize, PostIndex)); 153 154 // Fill the FixedArray with the hole value. 155 ASSERT_EQ(2 * kPointerSize, FixedArray::kHeaderSize); 156 ASSERT(initial_capacity <= kLoopUnfoldLimit); 157 __ LoadRoot(scratch3, Heap::kTheHoleValueRootIndex); 158 for (int i = 0; i < initial_capacity; i++) { 159 __ str(scratch3, MemOperand(scratch1, kPointerSize, PostIndex)); 160 } 161} 162 163// Allocate a JSArray with the number of elements stored in a register. The 164// register array_function holds the built-in Array function and the register 165// array_size holds the size of the array as a smi. The allocated array is put 166// into the result register and beginning and end of the FixedArray elements 167// storage is put into registers elements_array_storage and elements_array_end 168// (see below for when that is not the case). If the parameter fill_with_holes 169// is true the allocated elements backing store is filled with the hole values 170// otherwise it is left uninitialized. When the backing store is filled the 171// register elements_array_storage is scratched. 172static void AllocateJSArray(MacroAssembler* masm, 173 Register array_function, // Array function. 174 Register array_size, // As a smi. 175 Register result, 176 Register elements_array_storage, 177 Register elements_array_end, 178 Register scratch1, 179 Register scratch2, 180 bool fill_with_hole, 181 Label* gc_required) { 182 Label not_empty, allocated; 183 184 // Load the initial map from the array function. 185 __ ldr(elements_array_storage, 186 FieldMemOperand(array_function, 187 JSFunction::kPrototypeOrInitialMapOffset)); 188 189 // Check whether an empty sized array is requested. 190 __ tst(array_size, array_size); 191 __ b(nz, ¬_empty); 192 193 // If an empty array is requested allocate a small elements array anyway. This 194 // keeps the code below free of special casing for the empty array. 195 int size = JSArray::kSize + 196 FixedArray::SizeFor(JSArray::kPreallocatedArrayElements); 197 __ AllocateInNewSpace(size, 198 result, 199 elements_array_end, 200 scratch1, 201 gc_required, 202 TAG_OBJECT); 203 __ jmp(&allocated); 204 205 // Allocate the JSArray object together with space for a FixedArray with the 206 // requested number of elements. 207 __ bind(¬_empty); 208 ASSERT(kSmiTagSize == 1 && kSmiTag == 0); 209 __ mov(elements_array_end, 210 Operand((JSArray::kSize + FixedArray::kHeaderSize) / kPointerSize)); 211 __ add(elements_array_end, 212 elements_array_end, 213 Operand(array_size, ASR, kSmiTagSize)); 214 __ AllocateInNewSpace( 215 elements_array_end, 216 result, 217 scratch1, 218 scratch2, 219 gc_required, 220 static_cast<AllocationFlags>(TAG_OBJECT | SIZE_IN_WORDS)); 221 222 // Allocated the JSArray. Now initialize the fields except for the elements 223 // array. 224 // result: JSObject 225 // elements_array_storage: initial map 226 // array_size: size of array (smi) 227 __ bind(&allocated); 228 __ str(elements_array_storage, FieldMemOperand(result, JSObject::kMapOffset)); 229 __ LoadRoot(elements_array_storage, Heap::kEmptyFixedArrayRootIndex); 230 __ str(elements_array_storage, 231 FieldMemOperand(result, JSArray::kPropertiesOffset)); 232 // Field JSArray::kElementsOffset is initialized later. 233 __ str(array_size, FieldMemOperand(result, JSArray::kLengthOffset)); 234 235 // Calculate the location of the elements array and set elements array member 236 // of the JSArray. 237 // result: JSObject 238 // array_size: size of array (smi) 239 __ add(elements_array_storage, result, Operand(JSArray::kSize)); 240 __ str(elements_array_storage, 241 FieldMemOperand(result, JSArray::kElementsOffset)); 242 243 // Clear the heap tag on the elements array. 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 249 // stored as a smi. 250 // result: JSObject 251 // elements_array_storage: elements array (untagged) 252 // array_size: size of array (smi) 253 __ LoadRoot(scratch1, Heap::kFixedArrayMapRootIndex); 254 ASSERT_EQ(0 * kPointerSize, FixedArray::kMapOffset); 255 __ str(scratch1, MemOperand(elements_array_storage, kPointerSize, PostIndex)); 256 ASSERT(kSmiTag == 0); 257 __ tst(array_size, array_size); 258 // Length of the FixedArray is the number of pre-allocated elements if 259 // the actual JSArray has length 0 and the size of the JSArray for non-empty 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); 265 ASSERT_EQ(1 * kPointerSize, FixedArray::kLengthOffset); 266 __ str(array_size, 267 MemOperand(elements_array_storage, kPointerSize, PostIndex)); 268 269 // Calculate elements array and elements array end. 270 // result: JSObject 271 // elements_array_storage: elements array element storage 272 // array_size: smi-tagged size of elements array 273 ASSERT(kSmiTag == 0 && kSmiTagSize < kPointerSizeLog2); 274 __ add(elements_array_end, 275 elements_array_storage, 276 Operand(array_size, LSL, kPointerSizeLog2 - kSmiTagSize)); 277 278 // Fill the allocated FixedArray with the hole value if requested. 279 // result: JSObject 280 // elements_array_storage: elements array element storage 281 // elements_array_end: start of next object 282 if (fill_with_hole) { 283 Label loop, entry; 284 __ LoadRoot(scratch1, Heap::kTheHoleValueRootIndex); 285 __ jmp(&entry); 286 __ bind(&loop); 287 __ str(scratch1, 288 MemOperand(elements_array_storage, kPointerSize, PostIndex)); 289 __ bind(&entry); 290 __ cmp(elements_array_storage, elements_array_end); 291 __ b(lt, &loop); 292 } 293} 294 295// Create a new array for the built-in Array function. This function allocates 296// the JSArray object and the FixedArray elements array and initializes these. 297// If the Array cannot be constructed in native code the runtime is called. This 298// function assumes the following state: 299// r0: argc 300// r1: constructor (built-in Array function) 301// lr: return address 302// sp[0]: last argument 303// This function is used for both construct and normal calls of Array. The only 304// difference between handling a construct call and a normal call is that for a 305// construct call the constructor function in r1 needs to be preserved for 306// entering the generic code. In both cases argc in r0 needs to be preserved. 307// Both registers are preserved by this code so no need to differentiate between 308// construct call and normal call. 309static void ArrayNativeCode(MacroAssembler* masm, 310 Label* call_generic_code) { 311 Label argc_one_or_more, argc_two_or_more; 312 313 // Check for array construction with zero arguments or one. 314 __ cmp(r0, Operand(0)); 315 __ b(ne, &argc_one_or_more); 316 317 // Handle construction of an empty array. 318 AllocateEmptyJSArray(masm, 319 r1, 320 r2, 321 r3, 322 r4, 323 r5, 324 JSArray::kPreallocatedArrayElements, 325 call_generic_code); 326 __ IncrementCounter(&Counters::array_function_native, 1, r3, r4); 327 // Setup return value, remove receiver from stack and return. 328 __ mov(r0, r2); 329 __ add(sp, sp, Operand(kPointerSize)); 330 __ Jump(lr); 331 332 // Check for one argument. Bail out if argument is not smi or if it is 333 // negative. 334 __ bind(&argc_one_or_more); 335 __ cmp(r0, Operand(1)); 336 __ b(ne, &argc_two_or_more); 337 ASSERT(kSmiTag == 0); 338 __ ldr(r2, MemOperand(sp)); // Get the argument from the stack. 339 __ and_(r3, r2, Operand(kIntptrSignBit | kSmiTagMask), SetCC); 340 __ b(ne, call_generic_code); 341 342 // Handle construction of an empty array of a certain size. Bail out if size 343 // is too large to actually allocate an elements array. 344 ASSERT(kSmiTag == 0); 345 __ cmp(r2, Operand(JSObject::kInitialMaxFastElementArray << kSmiTagSize)); 346 __ b(ge, call_generic_code); 347 348 // r0: argc 349 // r1: constructor 350 // r2: array_size (smi) 351 // sp[0]: argument 352 AllocateJSArray(masm, 353 r1, 354 r2, 355 r3, 356 r4, 357 r5, 358 r6, 359 r7, 360 true, 361 call_generic_code); 362 __ IncrementCounter(&Counters::array_function_native, 1, r2, r4); 363 // Setup return value, remove receiver and argument from stack and return. 364 __ mov(r0, r3); 365 __ add(sp, sp, Operand(2 * kPointerSize)); 366 __ Jump(lr); 367 368 // Handle construction of an array from a list of arguments. 369 __ bind(&argc_two_or_more); 370 __ mov(r2, Operand(r0, LSL, kSmiTagSize)); // Convet argc to a smi. 371 372 // r0: argc 373 // r1: constructor 374 // r2: array_size (smi) 375 // sp[0]: last argument 376 AllocateJSArray(masm, 377 r1, 378 r2, 379 r3, 380 r4, 381 r5, 382 r6, 383 r7, 384 false, 385 call_generic_code); 386 __ IncrementCounter(&Counters::array_function_native, 1, r2, r6); 387 388 // Fill arguments as array elements. Copy from the top of the stack (last 389 // element) to the array backing store filling it backwards. Note: 390 // elements_array_end points after the backing store therefore PreIndex is 391 // used when filling the backing store. 392 // r0: argc 393 // r3: JSArray 394 // r4: elements_array storage start (untagged) 395 // r5: elements_array_end (untagged) 396 // sp[0]: last argument 397 Label loop, entry; 398 __ jmp(&entry); 399 __ bind(&loop); 400 __ ldr(r2, MemOperand(sp, kPointerSize, PostIndex)); 401 __ str(r2, MemOperand(r5, -kPointerSize, PreIndex)); 402 __ bind(&entry); 403 __ cmp(r4, r5); 404 __ b(lt, &loop); 405 406 // Remove caller arguments and receiver from the stack, setup return value and 407 // return. 408 // r0: argc 409 // r3: JSArray 410 // sp[0]: receiver 411 __ add(sp, sp, Operand(kPointerSize)); 412 __ mov(r0, r3); 413 __ Jump(lr); 414} 415 416 417void Builtins::Generate_ArrayCode(MacroAssembler* masm) { 418 // ----------- S t a t e ------------- 419 // -- r0 : number of arguments 420 // -- lr : return address 421 // -- sp[...]: constructor arguments 422 // ----------------------------------- 423 Label generic_array_code, one_or_more_arguments, two_or_more_arguments; 424 425 // Get the Array function. 426 GenerateLoadArrayFunction(masm, r1); 427 428 if (FLAG_debug_code) { 429 // Initial map for the builtin Array function shoud be a map. 430 __ ldr(r2, FieldMemOperand(r1, JSFunction::kPrototypeOrInitialMapOffset)); 431 __ tst(r2, Operand(kSmiTagMask)); 432 __ Assert(ne, "Unexpected initial map for Array function"); 433 __ CompareObjectType(r2, r3, r4, MAP_TYPE); 434 __ Assert(eq, "Unexpected initial map for Array function"); 435 } 436 437 // Run the native code for the Array function called as a normal function. 438 ArrayNativeCode(masm, &generic_array_code); 439 440 // Jump to the generic array code if the specialized code cannot handle 441 // the construction. 442 __ bind(&generic_array_code); 443 Code* code = Builtins::builtin(Builtins::ArrayCodeGeneric); 444 Handle<Code> array_code(code); 445 __ Jump(array_code, RelocInfo::CODE_TARGET); 446} 447 448 449void Builtins::Generate_ArrayConstructCode(MacroAssembler* masm) { 450 // ----------- S t a t e ------------- 451 // -- r0 : number of arguments 452 // -- r1 : constructor function 453 // -- lr : return address 454 // -- sp[...]: constructor arguments 455 // ----------------------------------- 456 Label generic_constructor; 457 458 if (FLAG_debug_code) { 459 // The array construct code is only set for the builtin Array function which 460 // always have a map. 461 GenerateLoadArrayFunction(masm, r2); 462 __ cmp(r1, r2); 463 __ Assert(eq, "Unexpected Array function"); 464 // Initial map for the builtin Array function should be a map. 465 __ ldr(r2, FieldMemOperand(r1, JSFunction::kPrototypeOrInitialMapOffset)); 466 __ tst(r2, Operand(kSmiTagMask)); 467 __ Assert(ne, "Unexpected initial map for Array function"); 468 __ CompareObjectType(r2, r3, r4, MAP_TYPE); 469 __ Assert(eq, "Unexpected initial map for Array function"); 470 } 471 472 // Run the native code for the Array function called as a constructor. 473 ArrayNativeCode(masm, &generic_constructor); 474 475 // Jump to the generic construct code in case the specialized code cannot 476 // handle the construction. 477 __ bind(&generic_constructor); 478 Code* code = Builtins::builtin(Builtins::JSConstructStubGeneric); 479 Handle<Code> generic_construct_stub(code); 480 __ Jump(generic_construct_stub, RelocInfo::CODE_TARGET); 481} 482 483 484void Builtins::Generate_JSConstructCall(MacroAssembler* masm) { 485 // ----------- S t a t e ------------- 486 // -- r0 : number of arguments 487 // -- r1 : constructor function 488 // -- lr : return address 489 // -- sp[...]: constructor arguments 490 // ----------------------------------- 491 492 Label non_function_call; 493 // Check that the function is not a smi. 494 __ tst(r1, Operand(kSmiTagMask)); 495 __ b(eq, &non_function_call); 496 // Check that the function is a JSFunction. 497 __ CompareObjectType(r1, r2, r2, JS_FUNCTION_TYPE); 498 __ b(ne, &non_function_call); 499 500 // Jump to the function-specific construct stub. 501 __ ldr(r2, FieldMemOperand(r1, JSFunction::kSharedFunctionInfoOffset)); 502 __ ldr(r2, FieldMemOperand(r2, SharedFunctionInfo::kConstructStubOffset)); 503 __ add(pc, r2, Operand(Code::kHeaderSize - kHeapObjectTag)); 504 505 // r0: number of arguments 506 // r1: called object 507 __ bind(&non_function_call); 508 // CALL_NON_FUNCTION expects the non-function constructor as receiver 509 // (instead of the original receiver from the call site). The receiver is 510 // stack element argc. 511 __ str(r1, MemOperand(sp, r0, LSL, kPointerSizeLog2)); 512 // Set expected number of arguments to zero (not changing r0). 513 __ mov(r2, Operand(0)); 514 __ GetBuiltinEntry(r3, Builtins::CALL_NON_FUNCTION_AS_CONSTRUCTOR); 515 __ Jump(Handle<Code>(builtin(ArgumentsAdaptorTrampoline)), 516 RelocInfo::CODE_TARGET); 517} 518 519 520static void Generate_JSConstructStubHelper(MacroAssembler* masm, 521 bool is_api_function) { 522 // Enter a construct frame. 523 __ EnterConstructFrame(); 524 525 // Preserve the two incoming parameters on the stack. 526 __ mov(r0, Operand(r0, LSL, kSmiTagSize)); 527 __ push(r0); // Smi-tagged arguments count. 528 __ push(r1); // Constructor function. 529 530 // Use r7 for holding undefined which is used in several places below. 531 __ LoadRoot(r7, Heap::kUndefinedValueRootIndex); 532 533 // Try to allocate the object without transitioning into C code. If any of the 534 // preconditions is not met, the code bails out to the runtime call. 535 Label rt_call, allocated; 536 if (FLAG_inline_new) { 537 Label undo_allocation; 538#ifdef ENABLE_DEBUGGER_SUPPORT 539 ExternalReference debug_step_in_fp = 540 ExternalReference::debug_step_in_fp_address(); 541 __ mov(r2, Operand(debug_step_in_fp)); 542 __ ldr(r2, MemOperand(r2)); 543 __ tst(r2, r2); 544 __ b(nz, &rt_call); 545#endif 546 547 // Load the initial map and verify that it is in fact a map. 548 // r1: constructor function 549 // r7: undefined value 550 __ ldr(r2, FieldMemOperand(r1, JSFunction::kPrototypeOrInitialMapOffset)); 551 __ tst(r2, Operand(kSmiTagMask)); 552 __ b(eq, &rt_call); 553 __ CompareObjectType(r2, r3, r4, MAP_TYPE); 554 __ b(ne, &rt_call); 555 556 // Check that the constructor is not constructing a JSFunction (see comments 557 // in Runtime_NewObject in runtime.cc). In which case the initial map's 558 // instance type would be JS_FUNCTION_TYPE. 559 // r1: constructor function 560 // r2: initial map 561 // r7: undefined value 562 __ CompareInstanceType(r2, r3, JS_FUNCTION_TYPE); 563 __ b(eq, &rt_call); 564 565 // Now allocate the JSObject on the heap. 566 // r1: constructor function 567 // r2: initial map 568 // r7: undefined value 569 __ ldrb(r3, FieldMemOperand(r2, Map::kInstanceSizeOffset)); 570 __ AllocateInNewSpace(r3, r4, r5, r6, &rt_call, SIZE_IN_WORDS); 571 572 // Allocated the JSObject, now initialize the fields. Map is set to initial 573 // map and properties and elements are set to empty fixed array. 574 // r1: constructor function 575 // r2: initial map 576 // r3: object size 577 // r4: JSObject (not tagged) 578 // r7: undefined value 579 __ LoadRoot(r6, Heap::kEmptyFixedArrayRootIndex); 580 __ mov(r5, r4); 581 ASSERT_EQ(0 * kPointerSize, JSObject::kMapOffset); 582 __ str(r2, MemOperand(r5, kPointerSize, PostIndex)); 583 ASSERT_EQ(1 * kPointerSize, JSObject::kPropertiesOffset); 584 __ str(r6, MemOperand(r5, kPointerSize, PostIndex)); 585 ASSERT_EQ(2 * kPointerSize, JSObject::kElementsOffset); 586 __ str(r6, MemOperand(r5, kPointerSize, PostIndex)); 587 588 // Fill all the in-object properties with undefined. 589 // r1: constructor function 590 // r2: initial map 591 // r3: object size (in words) 592 // r4: JSObject (not tagged) 593 // r5: First in-object property of JSObject (not tagged) 594 // r7: undefined value 595 __ add(r6, r4, Operand(r3, LSL, kPointerSizeLog2)); // End of object. 596 ASSERT_EQ(3 * kPointerSize, JSObject::kHeaderSize); 597 { Label loop, entry; 598 __ b(&entry); 599 __ bind(&loop); 600 __ str(r7, MemOperand(r5, kPointerSize, PostIndex)); 601 __ bind(&entry); 602 __ cmp(r5, r6); 603 __ b(lt, &loop); 604 } 605 606 // Add the object tag to make the JSObject real, so that we can continue and 607 // jump into the continuation code at any time from now on. Any failures 608 // need to undo the allocation, so that the heap is in a consistent state 609 // and verifiable. 610 __ add(r4, r4, Operand(kHeapObjectTag)); 611 612 // Check if a non-empty properties array is needed. Continue with allocated 613 // object if not fall through to runtime call if it is. 614 // r1: constructor function 615 // r4: JSObject 616 // r5: start of next object (not tagged) 617 // r7: undefined value 618 __ ldrb(r3, FieldMemOperand(r2, Map::kUnusedPropertyFieldsOffset)); 619 // The field instance sizes contains both pre-allocated property fields and 620 // in-object properties. 621 __ ldr(r0, FieldMemOperand(r2, Map::kInstanceSizesOffset)); 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); 626 627 // Done if no extra properties are to be allocated. 628 __ b(eq, &allocated); 629 __ Assert(pl, "Property allocation count failed."); 630 631 // 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. 633 // r1: constructor 634 // r3: number of elements in properties array 635 // r4: JSObject 636 // r5: start of next object 637 // r7: undefined value 638 __ add(r0, r3, Operand(FixedArray::kHeaderSize / kPointerSize)); 639 __ AllocateInNewSpace( 640 r0, 641 r5, 642 r6, 643 r2, 644 &undo_allocation, 645 static_cast<AllocationFlags>(RESULT_CONTAINS_TOP | SIZE_IN_WORDS)); 646 647 // Initialize the FixedArray. 648 // r1: constructor 649 // r3: number of elements in properties array 650 // r4: JSObject 651 // r5: FixedArray (not tagged) 652 // r7: undefined value 653 __ LoadRoot(r6, Heap::kFixedArrayMapRootIndex); 654 __ mov(r2, r5); 655 ASSERT_EQ(0 * kPointerSize, JSObject::kMapOffset); 656 __ str(r6, 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)); 660 661 // Initialize the fields to undefined. 662 // r1: constructor function 663 // r2: First element of FixedArray (not tagged) 664 // r3: number of elements in properties array 665 // r4: JSObject 666 // r5: FixedArray (not tagged) 667 // r7: undefined 668 __ add(r6, r2, Operand(r3, LSL, kPointerSizeLog2)); // End of object. 669 ASSERT_EQ(2 * kPointerSize, FixedArray::kHeaderSize); 670 { Label loop, entry; 671 __ b(&entry); 672 __ bind(&loop); 673 __ str(r7, MemOperand(r2, kPointerSize, PostIndex)); 674 __ bind(&entry); 675 __ cmp(r2, r6); 676 __ b(lt, &loop); 677 } 678 679 // Store the initialized FixedArray into the properties field of 680 // the JSObject 681 // r1: constructor function 682 // r4: JSObject 683 // r5: FixedArray (not tagged) 684 __ add(r5, r5, Operand(kHeapObjectTag)); // Add the heap tag. 685 __ str(r5, FieldMemOperand(r4, JSObject::kPropertiesOffset)); 686 687 // Continue with JSObject being successfully allocated 688 // r1: constructor function 689 // r4: JSObject 690 __ jmp(&allocated); 691 692 // Undo the setting of the new top so that the heap is verifiable. For 693 // example, the map's unused properties potentially do not match the 694 // allocated objects unused properties. 695 // r4: JSObject (previous new top) 696 __ bind(&undo_allocation); 697 __ UndoAllocationInNewSpace(r4, r5); 698 } 699 700 // Allocate the new receiver object using the runtime call. 701 // r1: constructor function 702 __ bind(&rt_call); 703 __ push(r1); // argument for Runtime_NewObject 704 __ CallRuntime(Runtime::kNewObject, 1); 705 __ mov(r4, r0); 706 707 // Receiver for constructor call allocated. 708 // r4: JSObject 709 __ bind(&allocated); 710 __ push(r4); 711 712 // Push the function and the allocated receiver from the stack. 713 // sp[0]: receiver (newly allocated object) 714 // sp[1]: constructor function 715 // sp[2]: number of arguments (smi-tagged) 716 __ ldr(r1, MemOperand(sp, kPointerSize)); 717 __ push(r1); // Constructor function. 718 __ push(r4); // Receiver. 719 720 // Reload the number of arguments from the stack. 721 // r1: constructor function 722 // sp[0]: receiver 723 // sp[1]: constructor function 724 // sp[2]: receiver 725 // sp[3]: constructor function 726 // sp[4]: number of arguments (smi-tagged) 727 __ ldr(r3, MemOperand(sp, 4 * kPointerSize)); 728 729 // Setup pointer to last argument. 730 __ add(r2, fp, Operand(StandardFrameConstants::kCallerSPOffset)); 731 732 // Setup number of arguments for function call below 733 __ mov(r0, Operand(r3, LSR, kSmiTagSize)); 734 735 // Copy arguments and receiver to the expression stack. 736 // r0: number of arguments 737 // r2: address of last argument (caller sp) 738 // r1: constructor function 739 // r3: number of arguments (smi-tagged) 740 // sp[0]: receiver 741 // sp[1]: constructor function 742 // sp[2]: receiver 743 // sp[3]: constructor function 744 // sp[4]: number of arguments (smi-tagged) 745 Label loop, entry; 746 __ b(&entry); 747 __ bind(&loop); 748 __ ldr(ip, MemOperand(r2, r3, LSL, kPointerSizeLog2 - 1)); 749 __ push(ip); 750 __ bind(&entry); 751 __ sub(r3, r3, Operand(2), SetCC); 752 __ b(ge, &loop); 753 754 // Call the function. 755 // r0: number of arguments 756 // r1: constructor function 757 if (is_api_function) { 758 __ ldr(cp, FieldMemOperand(r1, JSFunction::kContextOffset)); 759 Handle<Code> code = Handle<Code>( 760 Builtins::builtin(Builtins::HandleApiCallConstruct)); 761 ParameterCount expected(0); 762 __ InvokeCode(code, expected, expected, 763 RelocInfo::CODE_TARGET, CALL_FUNCTION); 764 } else { 765 ParameterCount actual(r0); 766 __ InvokeFunction(r1, actual, CALL_FUNCTION); 767 } 768 769 // Pop the function from the stack. 770 // sp[0]: constructor function 771 // sp[2]: receiver 772 // sp[3]: constructor function 773 // sp[4]: number of arguments (smi-tagged) 774 __ pop(); 775 776 // Restore context from the frame. 777 // r0: result 778 // sp[0]: receiver 779 // sp[1]: constructor function 780 // sp[2]: number of arguments (smi-tagged) 781 __ ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset)); 782 783 // If the result is an object (in the ECMA sense), we should get rid 784 // of the receiver and use the result; see ECMA-262 section 13.2.2-7 785 // on page 74. 786 Label use_receiver, exit; 787 788 // If the result is a smi, it is *not* an object in the ECMA sense. 789 // r0: result 790 // sp[0]: receiver (newly allocated object) 791 // sp[1]: constructor function 792 // sp[2]: number of arguments (smi-tagged) 793 __ tst(r0, Operand(kSmiTagMask)); 794 __ b(eq, &use_receiver); 795 796 // If the type of the result (stored in its map) is less than 797 // FIRST_JS_OBJECT_TYPE, it is not an object in the ECMA sense. 798 __ CompareObjectType(r0, r3, r3, FIRST_JS_OBJECT_TYPE); 799 __ b(ge, &exit); 800 801 // Throw away the result of the constructor invocation and use the 802 // on-stack receiver as the result. 803 __ bind(&use_receiver); 804 __ ldr(r0, MemOperand(sp)); 805 806 // Remove receiver from the stack, remove caller arguments, and 807 // return. 808 __ bind(&exit); 809 // r0: result 810 // sp[0]: receiver (newly allocated object) 811 // sp[1]: constructor function 812 // sp[2]: number of arguments (smi-tagged) 813 __ ldr(r1, MemOperand(sp, 2 * kPointerSize)); 814 __ LeaveConstructFrame(); 815 __ add(sp, sp, Operand(r1, LSL, kPointerSizeLog2 - 1)); 816 __ add(sp, sp, Operand(kPointerSize)); 817 __ IncrementCounter(&Counters::constructed_objects, 1, r1, r2); 818 __ Jump(lr); 819} 820 821 822void Builtins::Generate_JSConstructStubGeneric(MacroAssembler* masm) { 823 Generate_JSConstructStubHelper(masm, false); 824} 825 826 827void Builtins::Generate_JSConstructStubApi(MacroAssembler* masm) { 828 Generate_JSConstructStubHelper(masm, true); 829} 830 831 832static void Generate_JSEntryTrampolineHelper(MacroAssembler* masm, 833 bool is_construct) { 834 // Called from Generate_JS_Entry 835 // r0: code entry 836 // r1: function 837 // r2: receiver 838 // r3: argc 839 // r4: argv 840 // r5-r7, cp may be clobbered 841 842 // Clear the context before we push it when entering the JS frame. 843 __ mov(cp, Operand(0)); 844 845 // Enter an internal frame. 846 __ EnterInternalFrame(); 847 848 // Set up the context from the function argument. 849 __ ldr(cp, FieldMemOperand(r1, JSFunction::kContextOffset)); 850 851 // Set up the roots register. 852 ExternalReference roots_address = ExternalReference::roots_address(); 853 __ mov(r10, Operand(roots_address)); 854 855 // Push the function and the receiver onto the stack. 856 __ push(r1); 857 __ push(r2); 858 859 // Copy arguments to the stack in a loop. 860 // r1: function 861 // r3: argc 862 // r4: argv, i.e. points to first arg 863 Label loop, entry; 864 __ add(r2, r4, Operand(r3, LSL, kPointerSizeLog2)); 865 // r2 points past last arg. 866 __ b(&entry); 867 __ bind(&loop); 868 __ ldr(r0, MemOperand(r4, kPointerSize, PostIndex)); // read next parameter 869 __ ldr(r0, MemOperand(r0)); // dereference handle 870 __ push(r0); // push parameter 871 __ bind(&entry); 872 __ cmp(r4, r2); 873 __ b(ne, &loop); 874 875 // Initialize all JavaScript callee-saved registers, since they will be seen 876 // by the garbage collector as part of handlers. 877 __ LoadRoot(r4, Heap::kUndefinedValueRootIndex); 878 __ mov(r5, Operand(r4)); 879 __ mov(r6, Operand(r4)); 880 __ mov(r7, Operand(r4)); 881 if (kR9Available == 1) { 882 __ mov(r9, Operand(r4)); 883 } 884 885 // Invoke the code and pass argc as r0. 886 __ mov(r0, Operand(r3)); 887 if (is_construct) { 888 __ Call(Handle<Code>(Builtins::builtin(Builtins::JSConstructCall)), 889 RelocInfo::CODE_TARGET); 890 } else { 891 ParameterCount actual(r0); 892 __ InvokeFunction(r1, actual, CALL_FUNCTION); 893 } 894 895 // Exit the JS frame and remove the parameters (except function), and return. 896 // Respect ABI stack constraint. 897 __ LeaveInternalFrame(); 898 __ Jump(lr); 899 900 // r0: result 901} 902 903 904void Builtins::Generate_JSEntryTrampoline(MacroAssembler* masm) { 905 Generate_JSEntryTrampolineHelper(masm, false); 906} 907 908 909void Builtins::Generate_JSConstructEntryTrampoline(MacroAssembler* masm) { 910 Generate_JSEntryTrampolineHelper(masm, true); 911} 912 913 914void Builtins::Generate_FunctionCall(MacroAssembler* masm) { 915 // 1. Make sure we have at least one argument. 916 // r0: actual number of arguments 917 { Label done; 918 __ tst(r0, Operand(r0)); 919 __ b(ne, &done); 920 __ LoadRoot(r2, Heap::kUndefinedValueRootIndex); 921 __ push(r2); 922 __ add(r0, r0, Operand(1)); 923 __ bind(&done); 924 } 925 926 // 2. Get the function to call (passed as receiver) from the stack, check 927 // if it is a function. 928 // r0: actual number of arguments 929 Label non_function; 930 __ ldr(r1, MemOperand(sp, r0, LSL, kPointerSizeLog2)); 931 __ tst(r1, Operand(kSmiTagMask)); 932 __ b(eq, &non_function); 933 __ CompareObjectType(r1, r2, r2, JS_FUNCTION_TYPE); 934 __ b(ne, &non_function); 935 936 // 3a. Patch the first argument if necessary when calling a function. 937 // r0: actual number of arguments 938 // r1: function 939 Label shift_arguments; 940 { Label convert_to_object, use_global_receiver, patch_receiver; 941 // Change context eagerly in case we need the global receiver. 942 __ ldr(cp, FieldMemOperand(r1, JSFunction::kContextOffset)); 943 944 __ add(r2, sp, Operand(r0, LSL, kPointerSizeLog2)); 945 __ ldr(r2, MemOperand(r2, -kPointerSize)); 946 // r0: actual number of arguments 947 // r1: function 948 // r2: first argument 949 __ tst(r2, Operand(kSmiTagMask)); 950 __ b(eq, &convert_to_object); 951 952 __ LoadRoot(r3, Heap::kNullValueRootIndex); 953 __ cmp(r2, r3); 954 __ b(eq, &use_global_receiver); 955 __ LoadRoot(r3, Heap::kUndefinedValueRootIndex); 956 __ cmp(r2, r3); 957 __ b(eq, &use_global_receiver); 958 959 __ CompareObjectType(r2, r3, r3, FIRST_JS_OBJECT_TYPE); 960 __ b(lt, &convert_to_object); 961 __ cmp(r3, Operand(LAST_JS_OBJECT_TYPE)); 962 __ b(le, &shift_arguments); 963 964 __ bind(&convert_to_object); 965 __ EnterInternalFrame(); // In order to preserve argument count. 966 __ mov(r0, Operand(r0, LSL, kSmiTagSize)); // Smi-tagged. 967 __ push(r0); 968 969 __ push(r2); 970 __ InvokeBuiltin(Builtins::TO_OBJECT, CALL_JS); 971 __ mov(r2, r0); 972 973 __ pop(r0); 974 __ mov(r0, Operand(r0, ASR, kSmiTagSize)); 975 __ LeaveInternalFrame(); 976 // Restore the function to r1. 977 __ ldr(r1, MemOperand(sp, r0, LSL, kPointerSizeLog2)); 978 __ jmp(&patch_receiver); 979 980 // Use the global receiver object from the called function as the 981 // receiver. 982 __ bind(&use_global_receiver); 983 const int kGlobalIndex = 984 Context::kHeaderSize + Context::GLOBAL_INDEX * kPointerSize; 985 __ ldr(r2, FieldMemOperand(cp, kGlobalIndex)); 986 __ ldr(r2, FieldMemOperand(r2, GlobalObject::kGlobalContextOffset)); 987 __ ldr(r2, FieldMemOperand(r2, kGlobalIndex)); 988 __ ldr(r2, FieldMemOperand(r2, GlobalObject::kGlobalReceiverOffset)); 989 990 __ bind(&patch_receiver); 991 __ add(r3, sp, Operand(r0, LSL, kPointerSizeLog2)); 992 __ str(r2, MemOperand(r3, -kPointerSize)); 993 994 __ jmp(&shift_arguments); 995 } 996 997 // 3b. Patch the first argument when calling a non-function. The 998 // CALL_NON_FUNCTION builtin expects the non-function callee as 999 // receiver, so overwrite the first argument which will ultimately 1000 // become the receiver. 1001 // r0: actual number of arguments 1002 // r1: function 1003 __ bind(&non_function); 1004 __ add(r2, sp, Operand(r0, LSL, kPointerSizeLog2)); 1005 __ str(r1, MemOperand(r2, -kPointerSize)); 1006 // Clear r1 to indicate a non-function being called. 1007 __ mov(r1, Operand(0)); 1008 1009 // 4. Shift arguments and return address one slot down on the stack 1010 // (overwriting the original receiver). Adjust argument count to make 1011 // the original first argument the new receiver. 1012 // r0: actual number of arguments 1013 // r1: function 1014 __ bind(&shift_arguments); 1015 { Label loop; 1016 // Calculate the copy start address (destination). Copy end address is sp. 1017 __ add(r2, sp, Operand(r0, LSL, kPointerSizeLog2)); 1018 1019 __ bind(&loop); 1020 __ ldr(ip, MemOperand(r2, -kPointerSize)); 1021 __ str(ip, MemOperand(r2)); 1022 __ sub(r2, r2, Operand(kPointerSize)); 1023 __ cmp(r2, sp); 1024 __ b(ne, &loop); 1025 // Adjust the actual number of arguments and remove the top element 1026 // (which is a copy of the last argument). 1027 __ sub(r0, r0, Operand(1)); 1028 __ pop(); 1029 } 1030 1031 // 5a. Call non-function via tail call to CALL_NON_FUNCTION builtin. 1032 // r0: actual number of arguments 1033 // r1: function 1034 { Label function; 1035 __ tst(r1, r1); 1036 __ b(ne, &function); 1037 __ mov(r2, Operand(0)); // expected arguments is 0 for CALL_NON_FUNCTION 1038 __ GetBuiltinEntry(r3, Builtins::CALL_NON_FUNCTION); 1039 __ Jump(Handle<Code>(builtin(ArgumentsAdaptorTrampoline)), 1040 RelocInfo::CODE_TARGET); 1041 __ bind(&function); 1042 } 1043 1044 // 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 1046 // (tail-call) to the code in register edx without checking arguments. 1047 // r0: actual number of arguments 1048 // r1: function 1049 __ ldr(r3, FieldMemOperand(r1, JSFunction::kSharedFunctionInfoOffset)); 1050 __ ldr(r2, 1051 FieldMemOperand(r3, SharedFunctionInfo::kFormalParameterCountOffset)); 1052 __ mov(r2, Operand(r2, ASR, kSmiTagSize)); 1053 __ ldr(r3, FieldMemOperand(r3, SharedFunctionInfo::kCodeOffset)); 1054 __ add(r3, r3, Operand(Code::kHeaderSize - kHeapObjectTag)); 1055 __ cmp(r2, r0); // Check formal and actual parameter counts. 1056 __ Jump(Handle<Code>(builtin(ArgumentsAdaptorTrampoline)), 1057 RelocInfo::CODE_TARGET, ne); 1058 1059 ParameterCount expected(0); 1060 __ InvokeCode(r3, expected, expected, JUMP_FUNCTION); 1061} 1062 1063 1064void Builtins::Generate_FunctionApply(MacroAssembler* masm) { 1065 const int kIndexOffset = -5 * kPointerSize; 1066 const int kLimitOffset = -4 * kPointerSize; 1067 const int kArgsOffset = 2 * kPointerSize; 1068 const int kRecvOffset = 3 * kPointerSize; 1069 const int kFunctionOffset = 4 * kPointerSize; 1070 1071 __ EnterInternalFrame(); 1072 1073 __ ldr(r0, MemOperand(fp, kFunctionOffset)); // get the function 1074 __ push(r0); 1075 __ ldr(r0, MemOperand(fp, kArgsOffset)); // get the args array 1076 __ push(r0); 1077 __ InvokeBuiltin(Builtins::APPLY_PREPARE, CALL_JS); 1078 1079 // Check the stack for overflow. We are not trying need to catch 1080 // interruptions (e.g. debug break and preemption) here, so the "real stack 1081 // limit" is checked. 1082 Label okay; 1083 __ LoadRoot(r2, Heap::kRealStackLimitRootIndex); 1084 // Make r2 the space we have left. The stack might already be overflowed 1085 // here which will cause r2 to become negative. 1086 __ sub(r2, sp, r2); 1087 // Check if the arguments will overflow the stack. 1088 __ cmp(r2, Operand(r0, LSL, kPointerSizeLog2 - kSmiTagSize)); 1089 __ b(gt, &okay); // Signed comparison. 1090 1091 // Out of stack space. 1092 __ ldr(r1, MemOperand(fp, kFunctionOffset)); 1093 __ push(r1); 1094 __ push(r0); 1095 __ InvokeBuiltin(Builtins::APPLY_OVERFLOW, CALL_JS); 1096 // End of stack check. 1097 1098 // Push current limit and index. 1099 __ bind(&okay); 1100 __ push(r0); // limit 1101 __ mov(r1, Operand(0)); // initial index 1102 __ push(r1); 1103 1104 // Change context eagerly to get the right global object if necessary. 1105 __ ldr(r0, MemOperand(fp, kFunctionOffset)); 1106 __ ldr(cp, FieldMemOperand(r0, JSFunction::kContextOffset)); 1107 1108 // Compute the receiver. 1109 Label call_to_object, use_global_receiver, push_receiver; 1110 __ ldr(r0, MemOperand(fp, kRecvOffset)); 1111 __ tst(r0, Operand(kSmiTagMask)); 1112 __ b(eq, &call_to_object); 1113 __ LoadRoot(r1, Heap::kNullValueRootIndex); 1114 __ cmp(r0, r1); 1115 __ b(eq, &use_global_receiver); 1116 __ LoadRoot(r1, Heap::kUndefinedValueRootIndex); 1117 __ cmp(r0, r1); 1118 __ b(eq, &use_global_receiver); 1119 1120 // Check if the receiver is already a JavaScript object. 1121 // r0: receiver 1122 __ CompareObjectType(r0, r1, r1, FIRST_JS_OBJECT_TYPE); 1123 __ b(lt, &call_to_object); 1124 __ cmp(r1, Operand(LAST_JS_OBJECT_TYPE)); 1125 __ b(le, &push_receiver); 1126 1127 // Convert the receiver to a regular object. 1128 // r0: receiver 1129 __ bind(&call_to_object); 1130 __ push(r0); 1131 __ InvokeBuiltin(Builtins::TO_OBJECT, CALL_JS); 1132 __ b(&push_receiver); 1133 1134 // Use the current global receiver object as the receiver. 1135 __ bind(&use_global_receiver); 1136 const int kGlobalOffset = 1137 Context::kHeaderSize + Context::GLOBAL_INDEX * kPointerSize; 1138 __ ldr(r0, FieldMemOperand(cp, kGlobalOffset)); 1139 __ ldr(r0, FieldMemOperand(r0, GlobalObject::kGlobalContextOffset)); 1140 __ ldr(r0, FieldMemOperand(r0, kGlobalOffset)); 1141 __ ldr(r0, FieldMemOperand(r0, GlobalObject::kGlobalReceiverOffset)); 1142 1143 // Push the receiver. 1144 // r0: receiver 1145 __ bind(&push_receiver); 1146 __ push(r0); 1147 1148 // Copy all arguments from the array to the stack. 1149 Label entry, loop; 1150 __ ldr(r0, MemOperand(fp, kIndexOffset)); 1151 __ b(&entry); 1152 1153 // Load the current argument from the arguments array and push it to the 1154 // stack. 1155 // r0: current argument index 1156 __ bind(&loop); 1157 __ ldr(r1, MemOperand(fp, kArgsOffset)); 1158 __ push(r1); 1159 __ push(r0); 1160 1161 // Call the runtime to access the property in the arguments array. 1162 __ CallRuntime(Runtime::kGetProperty, 2); 1163 __ push(r0); 1164 1165 // Use inline caching to access the arguments. 1166 __ ldr(r0, MemOperand(fp, kIndexOffset)); 1167 __ add(r0, r0, Operand(1 << kSmiTagSize)); 1168 __ str(r0, MemOperand(fp, kIndexOffset)); 1169 1170 // Test if the copy loop has finished copying all the elements from the 1171 // arguments object. 1172 __ bind(&entry); 1173 __ ldr(r1, MemOperand(fp, kLimitOffset)); 1174 __ cmp(r0, r1); 1175 __ b(ne, &loop); 1176 1177 // Invoke the function. 1178 ParameterCount actual(r0); 1179 __ mov(r0, Operand(r0, ASR, kSmiTagSize)); 1180 __ ldr(r1, MemOperand(fp, kFunctionOffset)); 1181 __ InvokeFunction(r1, actual, CALL_FUNCTION); 1182 1183 // Tear down the internal frame and remove function, receiver and args. 1184 __ LeaveInternalFrame(); 1185 __ add(sp, sp, Operand(3 * kPointerSize)); 1186 __ Jump(lr); 1187} 1188 1189 1190static void EnterArgumentsAdaptorFrame(MacroAssembler* masm) { 1191 __ mov(r0, Operand(r0, LSL, kSmiTagSize)); 1192 __ mov(r4, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR))); 1193 __ stm(db_w, sp, r0.bit() | r1.bit() | r4.bit() | fp.bit() | lr.bit()); 1194 __ add(fp, sp, Operand(3 * kPointerSize)); 1195} 1196 1197 1198static void LeaveArgumentsAdaptorFrame(MacroAssembler* masm) { 1199 // ----------- S t a t e ------------- 1200 // -- r0 : result being passed through 1201 // ----------------------------------- 1202 // Get the number of arguments passed (as a smi), tear down the frame and 1203 // then tear down the parameters. 1204 __ ldr(r1, MemOperand(fp, -3 * kPointerSize)); 1205 __ mov(sp, fp); 1206 __ ldm(ia_w, sp, fp.bit() | lr.bit()); 1207 __ add(sp, sp, Operand(r1, LSL, kPointerSizeLog2 - kSmiTagSize)); 1208 __ add(sp, sp, Operand(kPointerSize)); // adjust for receiver 1209} 1210 1211 1212void Builtins::Generate_ArgumentsAdaptorTrampoline(MacroAssembler* masm) { 1213 // ----------- S t a t e ------------- 1214 // -- r0 : actual number of arguments 1215 // -- r1 : function (passed through to callee) 1216 // -- r2 : expected number of arguments 1217 // -- r3 : code entry to call 1218 // ----------------------------------- 1219 1220 Label invoke, dont_adapt_arguments; 1221 1222 Label enough, too_few; 1223 __ cmp(r0, r2); 1224 __ b(lt, &too_few); 1225 __ cmp(r2, Operand(SharedFunctionInfo::kDontAdaptArgumentsSentinel)); 1226 __ b(eq, &dont_adapt_arguments); 1227 1228 { // Enough parameters: actual >= expected 1229 __ bind(&enough); 1230 EnterArgumentsAdaptorFrame(masm); 1231 1232 // Calculate copy start address into r0 and copy end address into r2. 1233 // r0: actual number of arguments as a smi 1234 // r1: function 1235 // r2: expected number of arguments 1236 // r3: code entry to call 1237 __ add(r0, fp, Operand(r0, LSL, kPointerSizeLog2 - kSmiTagSize)); 1238 // adjust for return address and receiver 1239 __ add(r0, r0, Operand(2 * kPointerSize)); 1240 __ sub(r2, r0, Operand(r2, LSL, kPointerSizeLog2)); 1241 1242 // Copy the arguments (including the receiver) to the new stack frame. 1243 // r0: copy start address 1244 // r1: function 1245 // r2: copy end address 1246 // r3: code entry to call 1247 1248 Label copy; 1249 __ bind(©); 1250 __ ldr(ip, MemOperand(r0, 0)); 1251 __ push(ip); 1252 __ cmp(r0, r2); // Compare before moving to next argument. 1253 __ sub(r0, r0, Operand(kPointerSize)); 1254 __ b(ne, ©); 1255 1256 __ b(&invoke); 1257 } 1258 1259 { // Too few parameters: Actual < expected 1260 __ bind(&too_few); 1261 EnterArgumentsAdaptorFrame(masm); 1262 1263 // Calculate copy start address into r0 and copy end address is fp. 1264 // r0: actual number of arguments as a smi 1265 // r1: function 1266 // r2: expected number of arguments 1267 // r3: code entry to call 1268 __ add(r0, fp, Operand(r0, LSL, kPointerSizeLog2 - kSmiTagSize)); 1269 1270 // Copy the arguments (including the receiver) to the new stack frame. 1271 // r0: copy start address 1272 // r1: function 1273 // r2: expected number of arguments 1274 // r3: code entry to call 1275 Label copy; 1276 __ bind(©); 1277 // Adjust load for return address and receiver. 1278 __ ldr(ip, MemOperand(r0, 2 * kPointerSize)); 1279 __ push(ip); 1280 __ cmp(r0, fp); // Compare before moving to next argument. 1281 __ sub(r0, r0, Operand(kPointerSize)); 1282 __ b(ne, ©); 1283 1284 // Fill the remaining expected arguments with undefined. 1285 // r1: function 1286 // r2: expected number of arguments 1287 // r3: code entry to call 1288 __ LoadRoot(ip, Heap::kUndefinedValueRootIndex); 1289 __ sub(r2, fp, Operand(r2, LSL, kPointerSizeLog2)); 1290 __ sub(r2, r2, Operand(4 * kPointerSize)); // Adjust for frame. 1291 1292 Label fill; 1293 __ bind(&fill); 1294 __ push(ip); 1295 __ cmp(sp, r2); 1296 __ b(ne, &fill); 1297 } 1298 1299 // Call the entry point. 1300 __ bind(&invoke); 1301 __ Call(r3); 1302 1303 // Exit frame and return. 1304 LeaveArgumentsAdaptorFrame(masm); 1305 __ Jump(lr); 1306 1307 1308 // ------------------------------------------- 1309 // Dont adapt arguments. 1310 // ------------------------------------------- 1311 __ bind(&dont_adapt_arguments); 1312 __ Jump(r3); 1313} 1314 1315 1316#undef __ 1317 1318} } // namespace v8::internal 1319 1320#endif // V8_TARGET_ARCH_ARM 1321