OLD | NEW |
1 // Copyright 2015 the V8 project authors. All rights reserved. | 1 // Copyright 2015 the V8 project authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "src/interpreter/bytecode-array-builder.h" | 5 #include "src/interpreter/bytecode-array-builder.h" |
6 #include "src/compiler.h" | 6 #include "src/compiler.h" |
7 #include "src/interpreter/interpreter-intrinsics.h" | 7 #include "src/interpreter/interpreter-intrinsics.h" |
8 | 8 |
9 namespace v8 { | 9 namespace v8 { |
10 namespace internal { | 10 namespace internal { |
(...skipping 241 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
252 | 252 |
253 void BytecodeArrayBuilder::OutputScaled(Bytecode bytecode, | 253 void BytecodeArrayBuilder::OutputScaled(Bytecode bytecode, |
254 OperandScale operand_scale, | 254 OperandScale operand_scale, |
255 uint32_t operand0) { | 255 uint32_t operand0) { |
256 uint32_t operands[] = {operand0}; | 256 uint32_t operands[] = {operand0}; |
257 Output(bytecode, operands, operand_scale); | 257 Output(bytecode, operands, operand_scale); |
258 } | 258 } |
259 | 259 |
260 BytecodeArrayBuilder& BytecodeArrayBuilder::BinaryOperation(Token::Value op, | 260 BytecodeArrayBuilder& BytecodeArrayBuilder::BinaryOperation(Token::Value op, |
261 Register reg) { | 261 Register reg) { |
262 OperandScale operand_scale = OperandSizesToScale(SizeForRegisterOperand(reg)); | 262 OperandScale operand_scale = OperandSizesToScale(reg.SizeOfOperand()); |
263 OutputScaled(BytecodeForBinaryOperation(op), operand_scale, | 263 OutputScaled(BytecodeForBinaryOperation(op), operand_scale, |
264 RegisterOperand(reg)); | 264 RegisterOperand(reg)); |
265 return *this; | 265 return *this; |
266 } | 266 } |
267 | 267 |
268 BytecodeArrayBuilder& BytecodeArrayBuilder::CountOperation(Token::Value op) { | 268 BytecodeArrayBuilder& BytecodeArrayBuilder::CountOperation(Token::Value op) { |
269 Output(BytecodeForCountOperation(op)); | 269 Output(BytecodeForCountOperation(op)); |
270 return *this; | 270 return *this; |
271 } | 271 } |
272 | 272 |
273 | 273 |
274 BytecodeArrayBuilder& BytecodeArrayBuilder::LogicalNot() { | 274 BytecodeArrayBuilder& BytecodeArrayBuilder::LogicalNot() { |
275 Output(Bytecode::kLogicalNot); | 275 Output(Bytecode::kLogicalNot); |
276 return *this; | 276 return *this; |
277 } | 277 } |
278 | 278 |
279 | 279 |
280 BytecodeArrayBuilder& BytecodeArrayBuilder::TypeOf() { | 280 BytecodeArrayBuilder& BytecodeArrayBuilder::TypeOf() { |
281 Output(Bytecode::kTypeOf); | 281 Output(Bytecode::kTypeOf); |
282 return *this; | 282 return *this; |
283 } | 283 } |
284 | 284 |
285 BytecodeArrayBuilder& BytecodeArrayBuilder::CompareOperation(Token::Value op, | 285 BytecodeArrayBuilder& BytecodeArrayBuilder::CompareOperation(Token::Value op, |
286 Register reg) { | 286 Register reg) { |
287 OperandScale operand_scale = OperandSizesToScale(SizeForRegisterOperand(reg)); | 287 OperandScale operand_scale = OperandSizesToScale(reg.SizeOfOperand()); |
288 OutputScaled(BytecodeForCompareOperation(op), operand_scale, | 288 OutputScaled(BytecodeForCompareOperation(op), operand_scale, |
289 RegisterOperand(reg)); | 289 RegisterOperand(reg)); |
290 return *this; | 290 return *this; |
291 } | 291 } |
292 | 292 |
293 | 293 |
294 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadLiteral( | 294 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadLiteral( |
295 v8::internal::Smi* smi) { | 295 v8::internal::Smi* smi) { |
296 int32_t raw_smi = smi->value(); | 296 int32_t raw_smi = smi->value(); |
297 if (raw_smi == 0) { | 297 if (raw_smi == 0) { |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
340 | 340 |
341 | 341 |
342 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadFalse() { | 342 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadFalse() { |
343 Output(Bytecode::kLdaFalse); | 343 Output(Bytecode::kLdaFalse); |
344 return *this; | 344 return *this; |
345 } | 345 } |
346 | 346 |
347 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadAccumulatorWithRegister( | 347 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadAccumulatorWithRegister( |
348 Register reg) { | 348 Register reg) { |
349 if (!IsRegisterInAccumulator(reg)) { | 349 if (!IsRegisterInAccumulator(reg)) { |
350 OperandScale operand_scale = | 350 OperandScale operand_scale = OperandSizesToScale(reg.SizeOfOperand()); |
351 OperandSizesToScale(SizeForRegisterOperand(reg)); | |
352 OutputScaled(Bytecode::kLdar, operand_scale, RegisterOperand(reg)); | 351 OutputScaled(Bytecode::kLdar, operand_scale, RegisterOperand(reg)); |
353 } | 352 } |
354 return *this; | 353 return *this; |
355 } | 354 } |
356 | 355 |
357 | 356 |
358 BytecodeArrayBuilder& BytecodeArrayBuilder::StoreAccumulatorInRegister( | 357 BytecodeArrayBuilder& BytecodeArrayBuilder::StoreAccumulatorInRegister( |
359 Register reg) { | 358 Register reg) { |
360 if (!IsRegisterInAccumulator(reg)) { | 359 if (!IsRegisterInAccumulator(reg)) { |
361 OperandScale operand_scale = | 360 OperandScale operand_scale = OperandSizesToScale(reg.SizeOfOperand()); |
362 OperandSizesToScale(SizeForRegisterOperand(reg)); | |
363 OutputScaled(Bytecode::kStar, operand_scale, RegisterOperand(reg)); | 361 OutputScaled(Bytecode::kStar, operand_scale, RegisterOperand(reg)); |
364 } | 362 } |
365 return *this; | 363 return *this; |
366 } | 364 } |
367 | 365 |
368 | 366 |
369 BytecodeArrayBuilder& BytecodeArrayBuilder::MoveRegister(Register from, | 367 BytecodeArrayBuilder& BytecodeArrayBuilder::MoveRegister(Register from, |
370 Register to) { | 368 Register to) { |
371 DCHECK(from != to); | 369 DCHECK(from != to); |
372 OperandScale operand_scale = OperandSizesToScale(SizeForRegisterOperand(from), | 370 OperandScale operand_scale = |
373 SizeForRegisterOperand(to)); | 371 OperandSizesToScale(from.SizeOfOperand(), to.SizeOfOperand()); |
374 OutputScaled(Bytecode::kMov, operand_scale, RegisterOperand(from), | 372 OutputScaled(Bytecode::kMov, operand_scale, RegisterOperand(from), |
375 RegisterOperand(to)); | 373 RegisterOperand(to)); |
376 return *this; | 374 return *this; |
377 } | 375 } |
378 | 376 |
379 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadGlobal( | 377 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadGlobal( |
380 const Handle<String> name, int feedback_slot, TypeofMode typeof_mode) { | 378 const Handle<String> name, int feedback_slot, TypeofMode typeof_mode) { |
381 // TODO(rmcilroy): Potentially store typeof information in an | 379 // TODO(rmcilroy): Potentially store typeof information in an |
382 // operand rather than having extra bytecodes. | 380 // operand rather than having extra bytecodes. |
383 Bytecode bytecode = BytecodeForLoadGlobal(typeof_mode); | 381 Bytecode bytecode = BytecodeForLoadGlobal(typeof_mode); |
(...skipping 15 matching lines...) Expand all Loading... |
399 SizeForUnsignedOperand(feedback_slot)); | 397 SizeForUnsignedOperand(feedback_slot)); |
400 OutputScaled(bytecode, operand_scale, UnsignedOperand(name_index), | 398 OutputScaled(bytecode, operand_scale, UnsignedOperand(name_index), |
401 UnsignedOperand(feedback_slot)); | 399 UnsignedOperand(feedback_slot)); |
402 return *this; | 400 return *this; |
403 } | 401 } |
404 | 402 |
405 | 403 |
406 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadContextSlot(Register context, | 404 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadContextSlot(Register context, |
407 int slot_index) { | 405 int slot_index) { |
408 OperandScale operand_scale = OperandSizesToScale( | 406 OperandScale operand_scale = OperandSizesToScale( |
409 SizeForRegisterOperand(context), SizeForUnsignedOperand(slot_index)); | 407 context.SizeOfOperand(), SizeForUnsignedOperand(slot_index)); |
410 OutputScaled(Bytecode::kLdaContextSlot, operand_scale, | 408 OutputScaled(Bytecode::kLdaContextSlot, operand_scale, |
411 RegisterOperand(context), UnsignedOperand(slot_index)); | 409 RegisterOperand(context), UnsignedOperand(slot_index)); |
412 return *this; | 410 return *this; |
413 } | 411 } |
414 | 412 |
415 | 413 |
416 BytecodeArrayBuilder& BytecodeArrayBuilder::StoreContextSlot(Register context, | 414 BytecodeArrayBuilder& BytecodeArrayBuilder::StoreContextSlot(Register context, |
417 int slot_index) { | 415 int slot_index) { |
418 OperandScale operand_scale = OperandSizesToScale( | 416 OperandScale operand_scale = OperandSizesToScale( |
419 SizeForRegisterOperand(context), SizeForUnsignedOperand(slot_index)); | 417 context.SizeOfOperand(), SizeForUnsignedOperand(slot_index)); |
420 OutputScaled(Bytecode::kStaContextSlot, operand_scale, | 418 OutputScaled(Bytecode::kStaContextSlot, operand_scale, |
421 RegisterOperand(context), UnsignedOperand(slot_index)); | 419 RegisterOperand(context), UnsignedOperand(slot_index)); |
422 return *this; | 420 return *this; |
423 } | 421 } |
424 | 422 |
425 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadLookupSlot( | 423 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadLookupSlot( |
426 const Handle<String> name, TypeofMode typeof_mode) { | 424 const Handle<String> name, TypeofMode typeof_mode) { |
427 Bytecode bytecode = (typeof_mode == INSIDE_TYPEOF) | 425 Bytecode bytecode = (typeof_mode == INSIDE_TYPEOF) |
428 ? Bytecode::kLdaLookupSlotInsideTypeof | 426 ? Bytecode::kLdaLookupSlotInsideTypeof |
429 : Bytecode::kLdaLookupSlot; | 427 : Bytecode::kLdaLookupSlot; |
(...skipping 11 matching lines...) Expand all Loading... |
441 OperandScale operand_scale = | 439 OperandScale operand_scale = |
442 OperandSizesToScale(SizeForUnsignedOperand(name_index)); | 440 OperandSizesToScale(SizeForUnsignedOperand(name_index)); |
443 OutputScaled(bytecode, operand_scale, UnsignedOperand(name_index)); | 441 OutputScaled(bytecode, operand_scale, UnsignedOperand(name_index)); |
444 return *this; | 442 return *this; |
445 } | 443 } |
446 | 444 |
447 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadNamedProperty( | 445 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadNamedProperty( |
448 Register object, const Handle<Name> name, int feedback_slot) { | 446 Register object, const Handle<Name> name, int feedback_slot) { |
449 size_t name_index = GetConstantPoolEntry(name); | 447 size_t name_index = GetConstantPoolEntry(name); |
450 OperandScale operand_scale = OperandSizesToScale( | 448 OperandScale operand_scale = OperandSizesToScale( |
451 SizeForRegisterOperand(object), SizeForUnsignedOperand(name_index), | 449 object.SizeOfOperand(), SizeForUnsignedOperand(name_index), |
452 SizeForUnsignedOperand(feedback_slot)); | 450 SizeForUnsignedOperand(feedback_slot)); |
453 OutputScaled(Bytecode::kLoadIC, operand_scale, RegisterOperand(object), | 451 OutputScaled(Bytecode::kLoadIC, operand_scale, RegisterOperand(object), |
454 UnsignedOperand(name_index), UnsignedOperand(feedback_slot)); | 452 UnsignedOperand(name_index), UnsignedOperand(feedback_slot)); |
455 return *this; | 453 return *this; |
456 } | 454 } |
457 | 455 |
458 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadKeyedProperty( | 456 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadKeyedProperty( |
459 Register object, int feedback_slot) { | 457 Register object, int feedback_slot) { |
460 OperandScale operand_scale = OperandSizesToScale( | 458 OperandScale operand_scale = OperandSizesToScale( |
461 SizeForRegisterOperand(object), SizeForUnsignedOperand(feedback_slot)); | 459 object.SizeOfOperand(), SizeForUnsignedOperand(feedback_slot)); |
462 OutputScaled(Bytecode::kKeyedLoadIC, operand_scale, RegisterOperand(object), | 460 OutputScaled(Bytecode::kKeyedLoadIC, operand_scale, RegisterOperand(object), |
463 UnsignedOperand(feedback_slot)); | 461 UnsignedOperand(feedback_slot)); |
464 return *this; | 462 return *this; |
465 } | 463 } |
466 | 464 |
467 BytecodeArrayBuilder& BytecodeArrayBuilder::StoreNamedProperty( | 465 BytecodeArrayBuilder& BytecodeArrayBuilder::StoreNamedProperty( |
468 Register object, const Handle<Name> name, int feedback_slot, | 466 Register object, const Handle<Name> name, int feedback_slot, |
469 LanguageMode language_mode) { | 467 LanguageMode language_mode) { |
470 Bytecode bytecode = BytecodeForStoreIC(language_mode); | 468 Bytecode bytecode = BytecodeForStoreIC(language_mode); |
471 size_t name_index = GetConstantPoolEntry(name); | 469 size_t name_index = GetConstantPoolEntry(name); |
472 OperandScale operand_scale = OperandSizesToScale( | 470 OperandScale operand_scale = OperandSizesToScale( |
473 SizeForRegisterOperand(object), SizeForUnsignedOperand(name_index), | 471 object.SizeOfOperand(), SizeForUnsignedOperand(name_index), |
474 SizeForUnsignedOperand(feedback_slot)); | 472 SizeForUnsignedOperand(feedback_slot)); |
475 OutputScaled(bytecode, operand_scale, RegisterOperand(object), | 473 OutputScaled(bytecode, operand_scale, RegisterOperand(object), |
476 UnsignedOperand(name_index), UnsignedOperand(feedback_slot)); | 474 UnsignedOperand(name_index), UnsignedOperand(feedback_slot)); |
477 return *this; | 475 return *this; |
478 } | 476 } |
479 | 477 |
480 | 478 |
481 BytecodeArrayBuilder& BytecodeArrayBuilder::StoreKeyedProperty( | 479 BytecodeArrayBuilder& BytecodeArrayBuilder::StoreKeyedProperty( |
482 Register object, Register key, int feedback_slot, | 480 Register object, Register key, int feedback_slot, |
483 LanguageMode language_mode) { | 481 LanguageMode language_mode) { |
484 Bytecode bytecode = BytecodeForKeyedStoreIC(language_mode); | 482 Bytecode bytecode = BytecodeForKeyedStoreIC(language_mode); |
485 OperandScale operand_scale = OperandSizesToScale( | 483 OperandScale operand_scale = |
486 SizeForRegisterOperand(object), SizeForRegisterOperand(key), | 484 OperandSizesToScale(object.SizeOfOperand(), key.SizeOfOperand(), |
487 SizeForUnsignedOperand(feedback_slot)); | 485 SizeForUnsignedOperand(feedback_slot)); |
488 OutputScaled(bytecode, operand_scale, RegisterOperand(object), | 486 OutputScaled(bytecode, operand_scale, RegisterOperand(object), |
489 RegisterOperand(key), UnsignedOperand(feedback_slot)); | 487 RegisterOperand(key), UnsignedOperand(feedback_slot)); |
490 return *this; | 488 return *this; |
491 } | 489 } |
492 | 490 |
493 | 491 |
494 BytecodeArrayBuilder& BytecodeArrayBuilder::CreateClosure( | 492 BytecodeArrayBuilder& BytecodeArrayBuilder::CreateClosure( |
495 Handle<SharedFunctionInfo> shared_info, PretenureFlag tenured) { | 493 Handle<SharedFunctionInfo> shared_info, PretenureFlag tenured) { |
496 size_t entry = GetConstantPoolEntry(shared_info); | 494 size_t entry = GetConstantPoolEntry(shared_info); |
497 OperandScale operand_scale = | 495 OperandScale operand_scale = |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
546 SizeForUnsignedOperand(constant_properties_entry), | 544 SizeForUnsignedOperand(constant_properties_entry), |
547 SizeForUnsignedOperand(literal_index), SizeForUnsignedOperand(flags)); | 545 SizeForUnsignedOperand(literal_index), SizeForUnsignedOperand(flags)); |
548 OutputScaled(Bytecode::kCreateObjectLiteral, operand_scale, | 546 OutputScaled(Bytecode::kCreateObjectLiteral, operand_scale, |
549 UnsignedOperand(constant_properties_entry), | 547 UnsignedOperand(constant_properties_entry), |
550 UnsignedOperand(literal_index), UnsignedOperand(flags)); | 548 UnsignedOperand(literal_index), UnsignedOperand(flags)); |
551 return *this; | 549 return *this; |
552 } | 550 } |
553 | 551 |
554 | 552 |
555 BytecodeArrayBuilder& BytecodeArrayBuilder::PushContext(Register context) { | 553 BytecodeArrayBuilder& BytecodeArrayBuilder::PushContext(Register context) { |
556 OperandScale operand_scale = | 554 OperandScale operand_scale = OperandSizesToScale(context.SizeOfOperand()); |
557 OperandSizesToScale(SizeForRegisterOperand(context)); | |
558 OutputScaled(Bytecode::kPushContext, operand_scale, RegisterOperand(context)); | 555 OutputScaled(Bytecode::kPushContext, operand_scale, RegisterOperand(context)); |
559 return *this; | 556 return *this; |
560 } | 557 } |
561 | 558 |
562 | 559 |
563 BytecodeArrayBuilder& BytecodeArrayBuilder::PopContext(Register context) { | 560 BytecodeArrayBuilder& BytecodeArrayBuilder::PopContext(Register context) { |
564 OperandScale operand_scale = | 561 OperandScale operand_scale = OperandSizesToScale(context.SizeOfOperand()); |
565 OperandSizesToScale(SizeForRegisterOperand(context)); | |
566 OutputScaled(Bytecode::kPopContext, operand_scale, RegisterOperand(context)); | 562 OutputScaled(Bytecode::kPopContext, operand_scale, RegisterOperand(context)); |
567 return *this; | 563 return *this; |
568 } | 564 } |
569 | 565 |
570 | 566 |
571 bool BytecodeArrayBuilder::NeedToBooleanCast() { | 567 bool BytecodeArrayBuilder::NeedToBooleanCast() { |
572 if (!LastBytecodeInSameBlock()) { | 568 if (!LastBytecodeInSameBlock()) { |
573 return true; | 569 return true; |
574 } | 570 } |
575 PreviousBytecodeHelper previous_bytecode(*this); | 571 PreviousBytecodeHelper previous_bytecode(*this); |
(...skipping 326 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
902 } | 898 } |
903 | 899 |
904 BytecodeArrayBuilder& BytecodeArrayBuilder::Debugger() { | 900 BytecodeArrayBuilder& BytecodeArrayBuilder::Debugger() { |
905 Output(Bytecode::kDebugger); | 901 Output(Bytecode::kDebugger); |
906 return *this; | 902 return *this; |
907 } | 903 } |
908 | 904 |
909 BytecodeArrayBuilder& BytecodeArrayBuilder::ForInPrepare( | 905 BytecodeArrayBuilder& BytecodeArrayBuilder::ForInPrepare( |
910 Register cache_info_triple) { | 906 Register cache_info_triple) { |
911 OperandScale operand_scale = | 907 OperandScale operand_scale = |
912 OperandSizesToScale(SizeForRegisterOperand(cache_info_triple)); | 908 OperandSizesToScale(cache_info_triple.SizeOfOperand()); |
913 OutputScaled(Bytecode::kForInPrepare, operand_scale, | 909 OutputScaled(Bytecode::kForInPrepare, operand_scale, |
914 RegisterOperand(cache_info_triple)); | 910 RegisterOperand(cache_info_triple)); |
915 return *this; | 911 return *this; |
916 } | 912 } |
917 | 913 |
918 BytecodeArrayBuilder& BytecodeArrayBuilder::ForInDone(Register index, | 914 BytecodeArrayBuilder& BytecodeArrayBuilder::ForInDone(Register index, |
919 Register cache_length) { | 915 Register cache_length) { |
920 OperandScale operand_scale = OperandSizesToScale( | 916 OperandScale operand_scale = |
921 SizeForRegisterOperand(index), SizeForRegisterOperand(cache_length)); | 917 OperandSizesToScale(index.SizeOfOperand(), cache_length.SizeOfOperand()); |
922 OutputScaled(Bytecode::kForInDone, operand_scale, RegisterOperand(index), | 918 OutputScaled(Bytecode::kForInDone, operand_scale, RegisterOperand(index), |
923 RegisterOperand(cache_length)); | 919 RegisterOperand(cache_length)); |
924 return *this; | 920 return *this; |
925 } | 921 } |
926 | 922 |
927 BytecodeArrayBuilder& BytecodeArrayBuilder::ForInNext( | 923 BytecodeArrayBuilder& BytecodeArrayBuilder::ForInNext( |
928 Register receiver, Register index, Register cache_type_array_pair, | 924 Register receiver, Register index, Register cache_type_array_pair, |
929 int feedback_slot) { | 925 int feedback_slot) { |
930 OperandScale operand_scale = OperandSizesToScale( | 926 OperandScale operand_scale = |
931 SizeForRegisterOperand(receiver), SizeForRegisterOperand(index), | 927 OperandSizesToScale(receiver.SizeOfOperand(), index.SizeOfOperand(), |
932 SizeForRegisterOperand(cache_type_array_pair), | 928 cache_type_array_pair.SizeOfOperand(), |
933 SizeForUnsignedOperand(feedback_slot)); | 929 SizeForUnsignedOperand(feedback_slot)); |
934 OutputScaled(Bytecode::kForInNext, operand_scale, RegisterOperand(receiver), | 930 OutputScaled(Bytecode::kForInNext, operand_scale, RegisterOperand(receiver), |
935 RegisterOperand(index), RegisterOperand(cache_type_array_pair), | 931 RegisterOperand(index), RegisterOperand(cache_type_array_pair), |
936 UnsignedOperand(feedback_slot)); | 932 UnsignedOperand(feedback_slot)); |
937 return *this; | 933 return *this; |
938 } | 934 } |
939 | 935 |
940 | 936 |
941 BytecodeArrayBuilder& BytecodeArrayBuilder::ForInStep(Register index) { | 937 BytecodeArrayBuilder& BytecodeArrayBuilder::ForInStep(Register index) { |
942 OperandScale operand_scale = | 938 OperandScale operand_scale = OperandSizesToScale(index.SizeOfOperand()); |
943 OperandSizesToScale(SizeForRegisterOperand(index)); | |
944 OutputScaled(Bytecode::kForInStep, operand_scale, RegisterOperand(index)); | 939 OutputScaled(Bytecode::kForInStep, operand_scale, RegisterOperand(index)); |
945 return *this; | 940 return *this; |
946 } | 941 } |
947 | 942 |
948 | 943 |
949 BytecodeArrayBuilder& BytecodeArrayBuilder::MarkHandler(int handler_id, | 944 BytecodeArrayBuilder& BytecodeArrayBuilder::MarkHandler(int handler_id, |
950 bool will_catch) { | 945 bool will_catch) { |
951 handler_table_builder()->SetHandlerTarget(handler_id, bytecodes()->size()); | 946 handler_table_builder()->SetHandlerTarget(handler_id, bytecodes()->size()); |
952 handler_table_builder()->SetPrediction(handler_id, will_catch); | 947 handler_table_builder()->SetPrediction(handler_id, will_catch); |
953 return *this; | 948 return *this; |
(...skipping 27 matching lines...) Expand all Loading... |
981 DCHECK(exit_seen_in_block_); | 976 DCHECK(exit_seen_in_block_); |
982 } | 977 } |
983 | 978 |
984 BytecodeArrayBuilder& BytecodeArrayBuilder::Call(Register callable, | 979 BytecodeArrayBuilder& BytecodeArrayBuilder::Call(Register callable, |
985 Register receiver_args, | 980 Register receiver_args, |
986 size_t receiver_args_count, | 981 size_t receiver_args_count, |
987 int feedback_slot, | 982 int feedback_slot, |
988 TailCallMode tail_call_mode) { | 983 TailCallMode tail_call_mode) { |
989 Bytecode bytecode = BytecodeForCall(tail_call_mode); | 984 Bytecode bytecode = BytecodeForCall(tail_call_mode); |
990 OperandScale operand_scale = OperandSizesToScale( | 985 OperandScale operand_scale = OperandSizesToScale( |
991 SizeForRegisterOperand(callable), SizeForRegisterOperand(receiver_args), | 986 callable.SizeOfOperand(), receiver_args.SizeOfOperand(), |
992 SizeForUnsignedOperand(receiver_args_count), | 987 SizeForUnsignedOperand(receiver_args_count), |
993 SizeForUnsignedOperand(feedback_slot)); | 988 SizeForUnsignedOperand(feedback_slot)); |
994 OutputScaled(bytecode, operand_scale, RegisterOperand(callable), | 989 OutputScaled(bytecode, operand_scale, RegisterOperand(callable), |
995 RegisterOperand(receiver_args), | 990 RegisterOperand(receiver_args), |
996 UnsignedOperand(receiver_args_count), | 991 UnsignedOperand(receiver_args_count), |
997 UnsignedOperand(feedback_slot)); | 992 UnsignedOperand(feedback_slot)); |
998 return *this; | 993 return *this; |
999 } | 994 } |
1000 | 995 |
1001 BytecodeArrayBuilder& BytecodeArrayBuilder::New(Register constructor, | 996 BytecodeArrayBuilder& BytecodeArrayBuilder::New(Register constructor, |
1002 Register first_arg, | 997 Register first_arg, |
1003 size_t arg_count) { | 998 size_t arg_count) { |
1004 if (!first_arg.is_valid()) { | 999 if (!first_arg.is_valid()) { |
1005 DCHECK_EQ(0u, arg_count); | 1000 DCHECK_EQ(0u, arg_count); |
1006 first_arg = Register(0); | 1001 first_arg = Register(0); |
1007 } | 1002 } |
1008 OperandScale operand_scale = OperandSizesToScale( | 1003 OperandScale operand_scale = OperandSizesToScale( |
1009 SizeForRegisterOperand(constructor), SizeForRegisterOperand(first_arg), | 1004 constructor.SizeOfOperand(), first_arg.SizeOfOperand(), |
1010 SizeForUnsignedOperand(arg_count)); | 1005 SizeForUnsignedOperand(arg_count)); |
1011 OutputScaled(Bytecode::kNew, operand_scale, RegisterOperand(constructor), | 1006 OutputScaled(Bytecode::kNew, operand_scale, RegisterOperand(constructor), |
1012 RegisterOperand(first_arg), UnsignedOperand(arg_count)); | 1007 RegisterOperand(first_arg), UnsignedOperand(arg_count)); |
1013 return *this; | 1008 return *this; |
1014 } | 1009 } |
1015 | 1010 |
1016 | 1011 |
1017 BytecodeArrayBuilder& BytecodeArrayBuilder::CallRuntime( | 1012 BytecodeArrayBuilder& BytecodeArrayBuilder::CallRuntime( |
1018 Runtime::FunctionId function_id, Register first_arg, size_t arg_count) { | 1013 Runtime::FunctionId function_id, Register first_arg, size_t arg_count) { |
1019 DCHECK_EQ(1, Runtime::FunctionForId(function_id)->result_size); | 1014 DCHECK_EQ(1, Runtime::FunctionForId(function_id)->result_size); |
1020 DCHECK(SizeForUnsignedOperand(function_id) <= OperandSize::kShort); | 1015 DCHECK(SizeForUnsignedOperand(function_id) <= OperandSize::kShort); |
1021 if (!first_arg.is_valid()) { | 1016 if (!first_arg.is_valid()) { |
1022 DCHECK_EQ(0u, arg_count); | 1017 DCHECK_EQ(0u, arg_count); |
1023 first_arg = Register(0); | 1018 first_arg = Register(0); |
1024 } | 1019 } |
1025 Bytecode bytecode = IntrinsicsHelper::IsSupported(function_id) | 1020 Bytecode bytecode = IntrinsicsHelper::IsSupported(function_id) |
1026 ? Bytecode::kInvokeIntrinsic | 1021 ? Bytecode::kInvokeIntrinsic |
1027 : Bytecode::kCallRuntime; | 1022 : Bytecode::kCallRuntime; |
1028 OperandScale operand_scale = OperandSizesToScale( | 1023 OperandScale operand_scale = OperandSizesToScale( |
1029 SizeForRegisterOperand(first_arg), SizeForUnsignedOperand(arg_count)); | 1024 first_arg.SizeOfOperand(), SizeForUnsignedOperand(arg_count)); |
1030 OutputScaled(bytecode, operand_scale, static_cast<uint16_t>(function_id), | 1025 OutputScaled(bytecode, operand_scale, static_cast<uint16_t>(function_id), |
1031 RegisterOperand(first_arg), UnsignedOperand(arg_count)); | 1026 RegisterOperand(first_arg), UnsignedOperand(arg_count)); |
1032 return *this; | 1027 return *this; |
1033 } | 1028 } |
1034 | 1029 |
1035 | 1030 |
1036 BytecodeArrayBuilder& BytecodeArrayBuilder::CallRuntimeForPair( | 1031 BytecodeArrayBuilder& BytecodeArrayBuilder::CallRuntimeForPair( |
1037 Runtime::FunctionId function_id, Register first_arg, size_t arg_count, | 1032 Runtime::FunctionId function_id, Register first_arg, size_t arg_count, |
1038 Register first_return) { | 1033 Register first_return) { |
1039 DCHECK_EQ(2, Runtime::FunctionForId(function_id)->result_size); | 1034 DCHECK_EQ(2, Runtime::FunctionForId(function_id)->result_size); |
1040 DCHECK(SizeForUnsignedOperand(function_id) <= OperandSize::kShort); | 1035 DCHECK(SizeForUnsignedOperand(function_id) <= OperandSize::kShort); |
1041 if (!first_arg.is_valid()) { | 1036 if (!first_arg.is_valid()) { |
1042 DCHECK_EQ(0u, arg_count); | 1037 DCHECK_EQ(0u, arg_count); |
1043 first_arg = Register(0); | 1038 first_arg = Register(0); |
1044 } | 1039 } |
1045 OperandScale operand_scale = OperandSizesToScale( | 1040 OperandScale operand_scale = OperandSizesToScale( |
1046 SizeForRegisterOperand(first_arg), SizeForUnsignedOperand(arg_count), | 1041 first_arg.SizeOfOperand(), SizeForUnsignedOperand(arg_count), |
1047 SizeForRegisterOperand(first_return)); | 1042 first_return.SizeOfOperand()); |
1048 OutputScaled(Bytecode::kCallRuntimeForPair, operand_scale, | 1043 OutputScaled(Bytecode::kCallRuntimeForPair, operand_scale, |
1049 static_cast<uint16_t>(function_id), RegisterOperand(first_arg), | 1044 static_cast<uint16_t>(function_id), RegisterOperand(first_arg), |
1050 UnsignedOperand(arg_count), RegisterOperand(first_return)); | 1045 UnsignedOperand(arg_count), RegisterOperand(first_return)); |
1051 return *this; | 1046 return *this; |
1052 } | 1047 } |
1053 | 1048 |
1054 BytecodeArrayBuilder& BytecodeArrayBuilder::CallJSRuntime( | 1049 BytecodeArrayBuilder& BytecodeArrayBuilder::CallJSRuntime( |
1055 int context_index, Register receiver_args, size_t receiver_args_count) { | 1050 int context_index, Register receiver_args, size_t receiver_args_count) { |
1056 OperandScale operand_scale = | 1051 OperandScale operand_scale = OperandSizesToScale( |
1057 OperandSizesToScale(SizeForUnsignedOperand(context_index), | 1052 SizeForUnsignedOperand(context_index), receiver_args.SizeOfOperand(), |
1058 SizeForRegisterOperand(receiver_args), | 1053 SizeForUnsignedOperand(receiver_args_count)); |
1059 SizeForUnsignedOperand(receiver_args_count)); | |
1060 OutputScaled(Bytecode::kCallJSRuntime, operand_scale, | 1054 OutputScaled(Bytecode::kCallJSRuntime, operand_scale, |
1061 UnsignedOperand(context_index), RegisterOperand(receiver_args), | 1055 UnsignedOperand(context_index), RegisterOperand(receiver_args), |
1062 UnsignedOperand(receiver_args_count)); | 1056 UnsignedOperand(receiver_args_count)); |
1063 return *this; | 1057 return *this; |
1064 } | 1058 } |
1065 | 1059 |
1066 | 1060 |
1067 BytecodeArrayBuilder& BytecodeArrayBuilder::Delete(Register object, | 1061 BytecodeArrayBuilder& BytecodeArrayBuilder::Delete(Register object, |
1068 LanguageMode language_mode) { | 1062 LanguageMode language_mode) { |
1069 OperandScale operand_scale = | 1063 OperandScale operand_scale = OperandSizesToScale(object.SizeOfOperand()); |
1070 OperandSizesToScale(SizeForRegisterOperand(object)); | |
1071 OutputScaled(BytecodeForDelete(language_mode), operand_scale, | 1064 OutputScaled(BytecodeForDelete(language_mode), operand_scale, |
1072 RegisterOperand(object)); | 1065 RegisterOperand(object)); |
1073 return *this; | 1066 return *this; |
1074 } | 1067 } |
1075 | 1068 |
1076 size_t BytecodeArrayBuilder::GetConstantPoolEntry(Handle<Object> object) { | 1069 size_t BytecodeArrayBuilder::GetConstantPoolEntry(Handle<Object> object) { |
1077 return constant_array_builder()->Insert(object); | 1070 return constant_array_builder()->Insert(object); |
1078 } | 1071 } |
1079 | 1072 |
1080 void BytecodeArrayBuilder::SetReturnPosition() { | 1073 void BytecodeArrayBuilder::SetReturnPosition() { |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1130 } | 1123 } |
1131 } // Fall-through | 1124 } // Fall-through |
1132 case OperandType::kFlag8: | 1125 case OperandType::kFlag8: |
1133 case OperandType::kIdx: | 1126 case OperandType::kIdx: |
1134 case OperandType::kRuntimeId: | 1127 case OperandType::kRuntimeId: |
1135 case OperandType::kImm: { | 1128 case OperandType::kImm: { |
1136 size_t unsigned_value = static_cast<size_t>(operand_value); | 1129 size_t unsigned_value = static_cast<size_t>(operand_value); |
1137 return SizeForUnsignedOperand(unsigned_value) <= operand_size; | 1130 return SizeForUnsignedOperand(unsigned_value) <= operand_size; |
1138 } | 1131 } |
1139 case OperandType::kMaybeReg: | 1132 case OperandType::kMaybeReg: |
1140 if (operand_value == 0) { | 1133 if (RegisterFromOperand(operand_value) == Register(0)) { |
1141 return true; | 1134 return true; |
1142 } | 1135 } |
1143 // Fall-through to kReg case. | 1136 // Fall-through to kReg case. |
1144 case OperandType::kReg: | 1137 case OperandType::kReg: |
1145 case OperandType::kRegOut: { | 1138 case OperandType::kRegOut: { |
1146 Register reg = RegisterFromOperand(operand_value); | 1139 Register reg = RegisterFromOperand(operand_value); |
1147 return RegisterIsValid(reg, operand_size); | 1140 return RegisterIsValid(reg, operand_size); |
1148 } | 1141 } |
1149 case OperandType::kRegOutPair: | 1142 case OperandType::kRegOutPair: |
1150 case OperandType::kRegPair: { | 1143 case OperandType::kRegPair: { |
(...skipping 16 matching lines...) Expand all Loading... |
1167 UNREACHABLE(); | 1160 UNREACHABLE(); |
1168 return false; | 1161 return false; |
1169 } | 1162 } |
1170 | 1163 |
1171 bool BytecodeArrayBuilder::RegisterIsValid(Register reg, | 1164 bool BytecodeArrayBuilder::RegisterIsValid(Register reg, |
1172 OperandSize reg_size) const { | 1165 OperandSize reg_size) const { |
1173 if (!reg.is_valid()) { | 1166 if (!reg.is_valid()) { |
1174 return false; | 1167 return false; |
1175 } | 1168 } |
1176 | 1169 |
1177 if (SizeForRegisterOperand(reg) > reg_size) { | 1170 if (reg.SizeOfOperand() > reg_size) { |
1178 return false; | 1171 return false; |
1179 } | 1172 } |
1180 | 1173 |
1181 if (reg.is_current_context() || reg.is_function_closure() || | 1174 if (reg.is_current_context() || reg.is_function_closure() || |
1182 reg.is_new_target()) { | 1175 reg.is_new_target()) { |
1183 return true; | 1176 return true; |
1184 } else if (reg.is_parameter()) { | 1177 } else if (reg.is_parameter()) { |
1185 int parameter_index = reg.ToParameterIndex(parameter_count()); | 1178 int parameter_index = reg.ToParameterIndex(parameter_count()); |
1186 return parameter_index >= 0 && parameter_index < parameter_count(); | 1179 return parameter_index >= 0 && parameter_index < parameter_count(); |
1187 } else if (reg.index() < fixed_register_count()) { | 1180 } else if (reg.index() < fixed_register_count()) { |
(...skipping 197 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1385 return Bytecode::kCall; | 1378 return Bytecode::kCall; |
1386 case TailCallMode::kAllow: | 1379 case TailCallMode::kAllow: |
1387 return Bytecode::kTailCall; | 1380 return Bytecode::kTailCall; |
1388 default: | 1381 default: |
1389 UNREACHABLE(); | 1382 UNREACHABLE(); |
1390 } | 1383 } |
1391 return Bytecode::kIllegal; | 1384 return Bytecode::kIllegal; |
1392 } | 1385 } |
1393 | 1386 |
1394 // static | 1387 // static |
1395 OperandSize BytecodeArrayBuilder::SizeForRegisterOperand(Register value) { | |
1396 if (value.is_byte_operand()) { | |
1397 return OperandSize::kByte; | |
1398 } else if (value.is_short_operand()) { | |
1399 return OperandSize::kShort; | |
1400 } else { | |
1401 return OperandSize::kQuad; | |
1402 } | |
1403 } | |
1404 | |
1405 // static | |
1406 OperandSize BytecodeArrayBuilder::SizeForSignedOperand(int value) { | 1388 OperandSize BytecodeArrayBuilder::SizeForSignedOperand(int value) { |
1407 if (kMinInt8 <= value && value <= kMaxInt8) { | 1389 if (kMinInt8 <= value && value <= kMaxInt8) { |
1408 return OperandSize::kByte; | 1390 return OperandSize::kByte; |
1409 } else if (kMinInt16 <= value && value <= kMaxInt16) { | 1391 } else if (kMinInt16 <= value && value <= kMaxInt16) { |
1410 return OperandSize::kShort; | 1392 return OperandSize::kShort; |
1411 } else { | 1393 } else { |
1412 return OperandSize::kQuad; | 1394 return OperandSize::kQuad; |
1413 } | 1395 } |
1414 } | 1396 } |
1415 | 1397 |
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1489 } | 1471 } |
1490 | 1472 |
1491 uint32_t BytecodeArrayBuilder::UnsignedOperand(size_t value) { | 1473 uint32_t BytecodeArrayBuilder::UnsignedOperand(size_t value) { |
1492 DCHECK_LE(value, kMaxUInt32); | 1474 DCHECK_LE(value, kMaxUInt32); |
1493 return static_cast<uint32_t>(value); | 1475 return static_cast<uint32_t>(value); |
1494 } | 1476 } |
1495 | 1477 |
1496 } // namespace interpreter | 1478 } // namespace interpreter |
1497 } // namespace internal | 1479 } // namespace internal |
1498 } // namespace v8 | 1480 } // namespace v8 |
OLD | NEW |