builtins-arm.cc revision 756813857a4c2a4d8ad2e805969d5768d3cf43a0
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_LazyCompile(MacroAssembler* masm) { 915 // Enter an internal frame. 916 __ EnterInternalFrame(); 917 918 // Preserve the function. 919 __ push(r1); 920 921 // Push the function on the stack as the argument to the runtime function. 922 __ push(r1); 923 __ CallRuntime(Runtime::kLazyCompile, 1); 924 // Calculate the entry point. 925 __ add(r2, r0, Operand(Code::kHeaderSize - kHeapObjectTag)); 926 // Restore saved function. 927 __ pop(r1); 928 929 // Tear down temporary frame. 930 __ LeaveInternalFrame(); 931 932 // Do a tail-call of the compiled function. 933 __ Jump(r2); 934} 935 936 937void Builtins::Generate_FunctionCall(MacroAssembler* masm) { 938 // 1. Make sure we have at least one argument. 939 // r0: actual number of arguments 940 { Label done; 941 __ tst(r0, Operand(r0)); 942 __ b(ne, &done); 943 __ LoadRoot(r2, Heap::kUndefinedValueRootIndex); 944 __ push(r2); 945 __ add(r0, r0, Operand(1)); 946 __ bind(&done); 947 } 948 949 // 2. Get the function to call (passed as receiver) from the stack, check 950 // if it is a function. 951 // r0: actual number of arguments 952 Label non_function; 953 __ ldr(r1, MemOperand(sp, r0, LSL, kPointerSizeLog2)); 954 __ tst(r1, Operand(kSmiTagMask)); 955 __ b(eq, &non_function); 956 __ CompareObjectType(r1, r2, r2, JS_FUNCTION_TYPE); 957 __ b(ne, &non_function); 958 959 // 3a. Patch the first argument if necessary when calling a function. 960 // r0: actual number of arguments 961 // r1: function 962 Label shift_arguments; 963 { Label convert_to_object, use_global_receiver, patch_receiver; 964 // Change context eagerly in case we need the global receiver. 965 __ ldr(cp, FieldMemOperand(r1, JSFunction::kContextOffset)); 966 967 __ add(r2, sp, Operand(r0, LSL, kPointerSizeLog2)); 968 __ ldr(r2, MemOperand(r2, -kPointerSize)); 969 // r0: actual number of arguments 970 // r1: function 971 // r2: first argument 972 __ tst(r2, Operand(kSmiTagMask)); 973 __ b(eq, &convert_to_object); 974 975 __ LoadRoot(r3, Heap::kNullValueRootIndex); 976 __ cmp(r2, r3); 977 __ b(eq, &use_global_receiver); 978 __ LoadRoot(r3, Heap::kUndefinedValueRootIndex); 979 __ cmp(r2, r3); 980 __ b(eq, &use_global_receiver); 981 982 __ CompareObjectType(r2, r3, r3, FIRST_JS_OBJECT_TYPE); 983 __ b(lt, &convert_to_object); 984 __ cmp(r3, Operand(LAST_JS_OBJECT_TYPE)); 985 __ b(le, &shift_arguments); 986 987 __ bind(&convert_to_object); 988 __ EnterInternalFrame(); // In order to preserve argument count. 989 __ mov(r0, Operand(r0, LSL, kSmiTagSize)); // Smi-tagged. 990 __ push(r0); 991 992 __ push(r2); 993 __ InvokeBuiltin(Builtins::TO_OBJECT, CALL_JS); 994 __ mov(r2, r0); 995 996 __ pop(r0); 997 __ mov(r0, Operand(r0, ASR, kSmiTagSize)); 998 __ LeaveInternalFrame(); 999 // Restore the function to r1. 1000 __ ldr(r1, MemOperand(sp, r0, LSL, kPointerSizeLog2)); 1001 __ jmp(&patch_receiver); 1002 1003 // Use the global receiver object from the called function as the 1004 // receiver. 1005 __ bind(&use_global_receiver); 1006 const int kGlobalIndex = 1007 Context::kHeaderSize + Context::GLOBAL_INDEX * kPointerSize; 1008 __ ldr(r2, FieldMemOperand(cp, kGlobalIndex)); 1009 __ ldr(r2, FieldMemOperand(r2, GlobalObject::kGlobalContextOffset)); 1010 __ ldr(r2, FieldMemOperand(r2, kGlobalIndex)); 1011 __ ldr(r2, FieldMemOperand(r2, GlobalObject::kGlobalReceiverOffset)); 1012 1013 __ bind(&patch_receiver); 1014 __ add(r3, sp, Operand(r0, LSL, kPointerSizeLog2)); 1015 __ str(r2, MemOperand(r3, -kPointerSize)); 1016 1017 __ jmp(&shift_arguments); 1018 } 1019 1020 // 3b. Patch the first argument when calling a non-function. The 1021 // CALL_NON_FUNCTION builtin expects the non-function callee as 1022 // receiver, so overwrite the first argument which will ultimately 1023 // become the receiver. 1024 // r0: actual number of arguments 1025 // r1: function 1026 __ bind(&non_function); 1027 __ add(r2, sp, Operand(r0, LSL, kPointerSizeLog2)); 1028 __ str(r1, MemOperand(r2, -kPointerSize)); 1029 // Clear r1 to indicate a non-function being called. 1030 __ mov(r1, Operand(0)); 1031 1032 // 4. Shift arguments and return address one slot down on the stack 1033 // (overwriting the original receiver). Adjust argument count to make 1034 // the original first argument the new receiver. 1035 // r0: actual number of arguments 1036 // r1: function 1037 __ bind(&shift_arguments); 1038 { Label loop; 1039 // Calculate the copy start address (destination). Copy end address is sp. 1040 __ add(r2, sp, Operand(r0, LSL, kPointerSizeLog2)); 1041 1042 __ bind(&loop); 1043 __ ldr(ip, MemOperand(r2, -kPointerSize)); 1044 __ str(ip, MemOperand(r2)); 1045 __ sub(r2, r2, Operand(kPointerSize)); 1046 __ cmp(r2, sp); 1047 __ b(ne, &loop); 1048 // Adjust the actual number of arguments and remove the top element 1049 // (which is a copy of the last argument). 1050 __ sub(r0, r0, Operand(1)); 1051 __ pop(); 1052 } 1053 1054 // 5a. Call non-function via tail call to CALL_NON_FUNCTION builtin. 1055 // r0: actual number of arguments 1056 // r1: function 1057 { Label function; 1058 __ tst(r1, r1); 1059 __ b(ne, &function); 1060 __ mov(r2, Operand(0)); // expected arguments is 0 for CALL_NON_FUNCTION 1061 __ GetBuiltinEntry(r3, Builtins::CALL_NON_FUNCTION); 1062 __ Jump(Handle<Code>(builtin(ArgumentsAdaptorTrampoline)), 1063 RelocInfo::CODE_TARGET); 1064 __ bind(&function); 1065 } 1066 1067 // 5b. Get the code to call from the function and check that the number of 1068 // expected arguments matches what we're providing. If so, jump 1069 // (tail-call) to the code in register edx without checking arguments. 1070 // r0: actual number of arguments 1071 // r1: function 1072 __ ldr(r3, FieldMemOperand(r1, JSFunction::kSharedFunctionInfoOffset)); 1073 __ ldr(r2, 1074 FieldMemOperand(r3, SharedFunctionInfo::kFormalParameterCountOffset)); 1075 __ mov(r2, Operand(r2, ASR, kSmiTagSize)); 1076 __ ldr(r3, FieldMemOperand(r1, JSFunction::kCodeOffset)); 1077 __ add(r3, r3, Operand(Code::kHeaderSize - kHeapObjectTag)); 1078 __ cmp(r2, r0); // Check formal and actual parameter counts. 1079 __ Jump(Handle<Code>(builtin(ArgumentsAdaptorTrampoline)), 1080 RelocInfo::CODE_TARGET, ne); 1081 1082 ParameterCount expected(0); 1083 __ InvokeCode(r3, expected, expected, JUMP_FUNCTION); 1084} 1085 1086 1087void Builtins::Generate_FunctionApply(MacroAssembler* masm) { 1088 const int kIndexOffset = -5 * kPointerSize; 1089 const int kLimitOffset = -4 * kPointerSize; 1090 const int kArgsOffset = 2 * kPointerSize; 1091 const int kRecvOffset = 3 * kPointerSize; 1092 const int kFunctionOffset = 4 * kPointerSize; 1093 1094 __ EnterInternalFrame(); 1095 1096 __ ldr(r0, MemOperand(fp, kFunctionOffset)); // get the function 1097 __ push(r0); 1098 __ ldr(r0, MemOperand(fp, kArgsOffset)); // get the args array 1099 __ push(r0); 1100 __ InvokeBuiltin(Builtins::APPLY_PREPARE, CALL_JS); 1101 1102 // Check the stack for overflow. We are not trying need to catch 1103 // interruptions (e.g. debug break and preemption) here, so the "real stack 1104 // limit" is checked. 1105 Label okay; 1106 __ LoadRoot(r2, Heap::kRealStackLimitRootIndex); 1107 // Make r2 the space we have left. The stack might already be overflowed 1108 // here which will cause r2 to become negative. 1109 __ sub(r2, sp, r2); 1110 // Check if the arguments will overflow the stack. 1111 __ cmp(r2, Operand(r0, LSL, kPointerSizeLog2 - kSmiTagSize)); 1112 __ b(gt, &okay); // Signed comparison. 1113 1114 // Out of stack space. 1115 __ ldr(r1, MemOperand(fp, kFunctionOffset)); 1116 __ push(r1); 1117 __ push(r0); 1118 __ InvokeBuiltin(Builtins::APPLY_OVERFLOW, CALL_JS); 1119 // End of stack check. 1120 1121 // Push current limit and index. 1122 __ bind(&okay); 1123 __ push(r0); // limit 1124 __ mov(r1, Operand(0)); // initial index 1125 __ push(r1); 1126 1127 // Change context eagerly to get the right global object if necessary. 1128 __ ldr(r0, MemOperand(fp, kFunctionOffset)); 1129 __ ldr(cp, FieldMemOperand(r0, JSFunction::kContextOffset)); 1130 1131 // Compute the receiver. 1132 Label call_to_object, use_global_receiver, push_receiver; 1133 __ ldr(r0, MemOperand(fp, kRecvOffset)); 1134 __ tst(r0, Operand(kSmiTagMask)); 1135 __ b(eq, &call_to_object); 1136 __ LoadRoot(r1, Heap::kNullValueRootIndex); 1137 __ cmp(r0, r1); 1138 __ b(eq, &use_global_receiver); 1139 __ LoadRoot(r1, Heap::kUndefinedValueRootIndex); 1140 __ cmp(r0, r1); 1141 __ b(eq, &use_global_receiver); 1142 1143 // Check if the receiver is already a JavaScript object. 1144 // r0: receiver 1145 __ CompareObjectType(r0, r1, r1, FIRST_JS_OBJECT_TYPE); 1146 __ b(lt, &call_to_object); 1147 __ cmp(r1, Operand(LAST_JS_OBJECT_TYPE)); 1148 __ b(le, &push_receiver); 1149 1150 // Convert the receiver to a regular object. 1151 // r0: receiver 1152 __ bind(&call_to_object); 1153 __ push(r0); 1154 __ InvokeBuiltin(Builtins::TO_OBJECT, CALL_JS); 1155 __ b(&push_receiver); 1156 1157 // Use the current global receiver object as the receiver. 1158 __ bind(&use_global_receiver); 1159 const int kGlobalOffset = 1160 Context::kHeaderSize + Context::GLOBAL_INDEX * kPointerSize; 1161 __ ldr(r0, FieldMemOperand(cp, kGlobalOffset)); 1162 __ ldr(r0, FieldMemOperand(r0, GlobalObject::kGlobalContextOffset)); 1163 __ ldr(r0, FieldMemOperand(r0, kGlobalOffset)); 1164 __ ldr(r0, FieldMemOperand(r0, GlobalObject::kGlobalReceiverOffset)); 1165 1166 // Push the receiver. 1167 // r0: receiver 1168 __ bind(&push_receiver); 1169 __ push(r0); 1170 1171 // Copy all arguments from the array to the stack. 1172 Label entry, loop; 1173 __ ldr(r0, MemOperand(fp, kIndexOffset)); 1174 __ b(&entry); 1175 1176 // Load the current argument from the arguments array and push it to the 1177 // stack. 1178 // r0: current argument index 1179 __ bind(&loop); 1180 __ ldr(r1, MemOperand(fp, kArgsOffset)); 1181 __ push(r1); 1182 __ push(r0); 1183 1184 // Call the runtime to access the property in the arguments array. 1185 __ CallRuntime(Runtime::kGetProperty, 2); 1186 __ push(r0); 1187 1188 // Use inline caching to access the arguments. 1189 __ ldr(r0, MemOperand(fp, kIndexOffset)); 1190 __ add(r0, r0, Operand(1 << kSmiTagSize)); 1191 __ str(r0, MemOperand(fp, kIndexOffset)); 1192 1193 // Test if the copy loop has finished copying all the elements from the 1194 // arguments object. 1195 __ bind(&entry); 1196 __ ldr(r1, MemOperand(fp, kLimitOffset)); 1197 __ cmp(r0, r1); 1198 __ b(ne, &loop); 1199 1200 // Invoke the function. 1201 ParameterCount actual(r0); 1202 __ mov(r0, Operand(r0, ASR, kSmiTagSize)); 1203 __ ldr(r1, MemOperand(fp, kFunctionOffset)); 1204 __ InvokeFunction(r1, actual, CALL_FUNCTION); 1205 1206 // Tear down the internal frame and remove function, receiver and args. 1207 __ LeaveInternalFrame(); 1208 __ add(sp, sp, Operand(3 * kPointerSize)); 1209 __ Jump(lr); 1210} 1211 1212 1213static void EnterArgumentsAdaptorFrame(MacroAssembler* masm) { 1214 __ mov(r0, Operand(r0, LSL, kSmiTagSize)); 1215 __ mov(r4, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR))); 1216 __ stm(db_w, sp, r0.bit() | r1.bit() | r4.bit() | fp.bit() | lr.bit()); 1217 __ add(fp, sp, Operand(3 * kPointerSize)); 1218} 1219 1220 1221static void LeaveArgumentsAdaptorFrame(MacroAssembler* masm) { 1222 // ----------- S t a t e ------------- 1223 // -- r0 : result being passed through 1224 // ----------------------------------- 1225 // Get the number of arguments passed (as a smi), tear down the frame and 1226 // then tear down the parameters. 1227 __ ldr(r1, MemOperand(fp, -3 * kPointerSize)); 1228 __ mov(sp, fp); 1229 __ ldm(ia_w, sp, fp.bit() | lr.bit()); 1230 __ add(sp, sp, Operand(r1, LSL, kPointerSizeLog2 - kSmiTagSize)); 1231 __ add(sp, sp, Operand(kPointerSize)); // adjust for receiver 1232} 1233 1234 1235void Builtins::Generate_ArgumentsAdaptorTrampoline(MacroAssembler* masm) { 1236 // ----------- S t a t e ------------- 1237 // -- r0 : actual number of arguments 1238 // -- r1 : function (passed through to callee) 1239 // -- r2 : expected number of arguments 1240 // -- r3 : code entry to call 1241 // ----------------------------------- 1242 1243 Label invoke, dont_adapt_arguments; 1244 1245 Label enough, too_few; 1246 __ cmp(r0, r2); 1247 __ b(lt, &too_few); 1248 __ cmp(r2, Operand(SharedFunctionInfo::kDontAdaptArgumentsSentinel)); 1249 __ b(eq, &dont_adapt_arguments); 1250 1251 { // Enough parameters: actual >= expected 1252 __ bind(&enough); 1253 EnterArgumentsAdaptorFrame(masm); 1254 1255 // Calculate copy start address into r0 and copy end address into r2. 1256 // r0: actual number of arguments as a smi 1257 // r1: function 1258 // r2: expected number of arguments 1259 // r3: code entry to call 1260 __ add(r0, fp, Operand(r0, LSL, kPointerSizeLog2 - kSmiTagSize)); 1261 // adjust for return address and receiver 1262 __ add(r0, r0, Operand(2 * kPointerSize)); 1263 __ sub(r2, r0, Operand(r2, LSL, kPointerSizeLog2)); 1264 1265 // Copy the arguments (including the receiver) to the new stack frame. 1266 // r0: copy start address 1267 // r1: function 1268 // r2: copy end address 1269 // r3: code entry to call 1270 1271 Label copy; 1272 __ bind(©); 1273 __ ldr(ip, MemOperand(r0, 0)); 1274 __ push(ip); 1275 __ cmp(r0, r2); // Compare before moving to next argument. 1276 __ sub(r0, r0, Operand(kPointerSize)); 1277 __ b(ne, ©); 1278 1279 __ b(&invoke); 1280 } 1281 1282 { // Too few parameters: Actual < expected 1283 __ bind(&too_few); 1284 EnterArgumentsAdaptorFrame(masm); 1285 1286 // Calculate copy start address into r0 and copy end address is fp. 1287 // r0: actual number of arguments as a smi 1288 // r1: function 1289 // r2: expected number of arguments 1290 // r3: code entry to call 1291 __ add(r0, fp, Operand(r0, LSL, kPointerSizeLog2 - kSmiTagSize)); 1292 1293 // Copy the arguments (including the receiver) to the new stack frame. 1294 // r0: copy start address 1295 // r1: function 1296 // r2: expected number of arguments 1297 // r3: code entry to call 1298 Label copy; 1299 __ bind(©); 1300 // Adjust load for return address and receiver. 1301 __ ldr(ip, MemOperand(r0, 2 * kPointerSize)); 1302 __ push(ip); 1303 __ cmp(r0, fp); // Compare before moving to next argument. 1304 __ sub(r0, r0, Operand(kPointerSize)); 1305 __ b(ne, ©); 1306 1307 // Fill the remaining expected arguments with undefined. 1308 // r1: function 1309 // r2: expected number of arguments 1310 // r3: code entry to call 1311 __ LoadRoot(ip, Heap::kUndefinedValueRootIndex); 1312 __ sub(r2, fp, Operand(r2, LSL, kPointerSizeLog2)); 1313 __ sub(r2, r2, Operand(4 * kPointerSize)); // Adjust for frame. 1314 1315 Label fill; 1316 __ bind(&fill); 1317 __ push(ip); 1318 __ cmp(sp, r2); 1319 __ b(ne, &fill); 1320 } 1321 1322 // Call the entry point. 1323 __ bind(&invoke); 1324 __ Call(r3); 1325 1326 // Exit frame and return. 1327 LeaveArgumentsAdaptorFrame(masm); 1328 __ Jump(lr); 1329 1330 1331 // ------------------------------------------- 1332 // Dont adapt arguments. 1333 // ------------------------------------------- 1334 __ bind(&dont_adapt_arguments); 1335 __ Jump(r3); 1336} 1337 1338 1339#undef __ 1340 1341} } // namespace v8::internal 1342 1343#endif // V8_TARGET_ARCH_ARM 1344