1// Copyright (c) 1994-2006 Sun Microsystems Inc. 2// All Rights Reserved. 3// 4// Redistribution and use in source and binary forms, with or without 5// modification, are permitted provided that the following conditions are 6// met: 7// 8// - Redistributions of source code must retain the above copyright notice, 9// this list of conditions and the following disclaimer. 10// 11// - Redistribution in binary form must reproduce the above copyright 12// notice, this list of conditions and the following disclaimer in the 13// documentation and/or other materials provided with the distribution. 14// 15// - Neither the name of Sun Microsystems or the names of contributors may 16// be used to endorse or promote products derived from this software without 17// specific prior written permission. 18// 19// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS 20// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 21// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 23// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 24// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 25// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 26// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 27// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 28// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 29// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 31// The original source code covered by the above license above has been 32// modified significantly by Google Inc. 33// Copyright 2012 the V8 project authors. All rights reserved. 34 35#ifndef V8_ASSEMBLER_H_ 36#define V8_ASSEMBLER_H_ 37 38#include "v8.h" 39 40#include "allocation.h" 41#include "builtins.h" 42#include "gdb-jit.h" 43#include "isolate.h" 44#include "runtime.h" 45#include "token.h" 46 47namespace v8 { 48 49class ApiFunction; 50 51namespace internal { 52 53struct StatsCounter; 54const unsigned kNoASTId = -1; 55// ----------------------------------------------------------------------------- 56// Platform independent assembler base class. 57 58class AssemblerBase: public Malloced { 59 public: 60 explicit AssemblerBase(Isolate* isolate); 61 62 Isolate* isolate() const { return isolate_; } 63 int jit_cookie() { return jit_cookie_; } 64 65 // Overwrite a host NaN with a quiet target NaN. Used by mksnapshot for 66 // cross-snapshotting. 67 static void QuietNaN(HeapObject* nan) { } 68 69 private: 70 Isolate* isolate_; 71 int jit_cookie_; 72}; 73 74 75// ----------------------------------------------------------------------------- 76// Labels represent pc locations; they are typically jump or call targets. 77// After declaration, a label can be freely used to denote known or (yet) 78// unknown pc location. Assembler::bind() is used to bind a label to the 79// current pc. A label can be bound only once. 80 81class Label BASE_EMBEDDED { 82 public: 83 enum Distance { 84 kNear, kFar 85 }; 86 87 INLINE(Label()) { 88 Unuse(); 89 UnuseNear(); 90 } 91 92 INLINE(~Label()) { 93 ASSERT(!is_linked()); 94 ASSERT(!is_near_linked()); 95 } 96 97 INLINE(void Unuse()) { pos_ = 0; } 98 INLINE(void UnuseNear()) { near_link_pos_ = 0; } 99 100 INLINE(bool is_bound() const) { return pos_ < 0; } 101 INLINE(bool is_unused() const) { return pos_ == 0 && near_link_pos_ == 0; } 102 INLINE(bool is_linked() const) { return pos_ > 0; } 103 INLINE(bool is_near_linked() const) { return near_link_pos_ > 0; } 104 105 // Returns the position of bound or linked labels. Cannot be used 106 // for unused labels. 107 int pos() const; 108 int near_link_pos() const { return near_link_pos_ - 1; } 109 110 private: 111 // pos_ encodes both the binding state (via its sign) 112 // and the binding position (via its value) of a label. 113 // 114 // pos_ < 0 bound label, pos() returns the jump target position 115 // pos_ == 0 unused label 116 // pos_ > 0 linked label, pos() returns the last reference position 117 int pos_; 118 119 // Behaves like |pos_| in the "> 0" case, but for near jumps to this label. 120 int near_link_pos_; 121 122 void bind_to(int pos) { 123 pos_ = -pos - 1; 124 ASSERT(is_bound()); 125 } 126 void link_to(int pos, Distance distance = kFar) { 127 if (distance == kNear) { 128 near_link_pos_ = pos + 1; 129 ASSERT(is_near_linked()); 130 } else { 131 pos_ = pos + 1; 132 ASSERT(is_linked()); 133 } 134 } 135 136 friend class Assembler; 137 friend class RegexpAssembler; 138 friend class Displacement; 139 friend class RegExpMacroAssemblerIrregexp; 140}; 141 142 143enum SaveFPRegsMode { kDontSaveFPRegs, kSaveFPRegs }; 144 145 146// ----------------------------------------------------------------------------- 147// Relocation information 148 149 150// Relocation information consists of the address (pc) of the datum 151// to which the relocation information applies, the relocation mode 152// (rmode), and an optional data field. The relocation mode may be 153// "descriptive" and not indicate a need for relocation, but simply 154// describe a property of the datum. Such rmodes are useful for GC 155// and nice disassembly output. 156 157class RelocInfo BASE_EMBEDDED { 158 public: 159 // The constant kNoPosition is used with the collecting of source positions 160 // in the relocation information. Two types of source positions are collected 161 // "position" (RelocMode position) and "statement position" (RelocMode 162 // statement_position). The "position" is collected at places in the source 163 // code which are of interest when making stack traces to pin-point the source 164 // location of a stack frame as close as possible. The "statement position" is 165 // collected at the beginning at each statement, and is used to indicate 166 // possible break locations. kNoPosition is used to indicate an 167 // invalid/uninitialized position value. 168 static const int kNoPosition = -1; 169 170 // This string is used to add padding comments to the reloc info in cases 171 // where we are not sure to have enough space for patching in during 172 // lazy deoptimization. This is the case if we have indirect calls for which 173 // we do not normally record relocation info. 174 static const char* const kFillerCommentString; 175 176 // The minimum size of a comment is equal to three bytes for the extra tagged 177 // pc + the tag for the data, and kPointerSize for the actual pointer to the 178 // comment. 179 static const int kMinRelocCommentSize = 3 + kPointerSize; 180 181 // The maximum size for a call instruction including pc-jump. 182 static const int kMaxCallSize = 6; 183 184 // The maximum pc delta that will use the short encoding. 185 static const int kMaxSmallPCDelta; 186 187 enum Mode { 188 // Please note the order is important (see IsCodeTarget, IsGCRelocMode). 189 CODE_TARGET, // Code target which is not any of the above. 190 CODE_TARGET_WITH_ID, 191 CONSTRUCT_CALL, // code target that is a call to a JavaScript constructor. 192 CODE_TARGET_CONTEXT, // Code target used for contextual loads and stores. 193 DEBUG_BREAK, // Code target for the debugger statement. 194 EMBEDDED_OBJECT, 195 GLOBAL_PROPERTY_CELL, 196 197 // Everything after runtime_entry (inclusive) is not GC'ed. 198 RUNTIME_ENTRY, 199 JS_RETURN, // Marks start of the ExitJSFrame code. 200 COMMENT, 201 POSITION, // See comment for kNoPosition above. 202 STATEMENT_POSITION, // See comment for kNoPosition above. 203 DEBUG_BREAK_SLOT, // Additional code inserted for debug break slot. 204 EXTERNAL_REFERENCE, // The address of an external C++ function. 205 INTERNAL_REFERENCE, // An address inside the same function. 206 207 // add more as needed 208 // Pseudo-types 209 NUMBER_OF_MODES, // There are at most 14 modes with noncompact encoding. 210 NONE, // never recorded 211 LAST_CODE_ENUM = DEBUG_BREAK, 212 LAST_GCED_ENUM = GLOBAL_PROPERTY_CELL, 213 // Modes <= LAST_COMPACT_ENUM are guaranteed to have compact encoding. 214 LAST_COMPACT_ENUM = CODE_TARGET_WITH_ID 215 }; 216 217 218 RelocInfo() {} 219 220 RelocInfo(byte* pc, Mode rmode, intptr_t data, Code* host) 221 : pc_(pc), rmode_(rmode), data_(data), host_(host) { 222 } 223 224 static inline bool IsConstructCall(Mode mode) { 225 return mode == CONSTRUCT_CALL; 226 } 227 static inline bool IsCodeTarget(Mode mode) { 228 return mode <= LAST_CODE_ENUM; 229 } 230 static inline bool IsEmbeddedObject(Mode mode) { 231 return mode == EMBEDDED_OBJECT; 232 } 233 // Is the relocation mode affected by GC? 234 static inline bool IsGCRelocMode(Mode mode) { 235 return mode <= LAST_GCED_ENUM; 236 } 237 static inline bool IsJSReturn(Mode mode) { 238 return mode == JS_RETURN; 239 } 240 static inline bool IsComment(Mode mode) { 241 return mode == COMMENT; 242 } 243 static inline bool IsPosition(Mode mode) { 244 return mode == POSITION || mode == STATEMENT_POSITION; 245 } 246 static inline bool IsStatementPosition(Mode mode) { 247 return mode == STATEMENT_POSITION; 248 } 249 static inline bool IsExternalReference(Mode mode) { 250 return mode == EXTERNAL_REFERENCE; 251 } 252 static inline bool IsInternalReference(Mode mode) { 253 return mode == INTERNAL_REFERENCE; 254 } 255 static inline bool IsDebugBreakSlot(Mode mode) { 256 return mode == DEBUG_BREAK_SLOT; 257 } 258 static inline int ModeMask(Mode mode) { return 1 << mode; } 259 260 // Accessors 261 byte* pc() const { return pc_; } 262 void set_pc(byte* pc) { pc_ = pc; } 263 Mode rmode() const { return rmode_; } 264 intptr_t data() const { return data_; } 265 Code* host() const { return host_; } 266 267 // Apply a relocation by delta bytes 268 INLINE(void apply(intptr_t delta)); 269 270 // Is the pointer this relocation info refers to coded like a plain pointer 271 // or is it strange in some way (e.g. relative or patched into a series of 272 // instructions). 273 bool IsCodedSpecially(); 274 275 // Read/modify the code target in the branch/call instruction 276 // this relocation applies to; 277 // can only be called if IsCodeTarget(rmode_) || rmode_ == RUNTIME_ENTRY 278 INLINE(Address target_address()); 279 INLINE(void set_target_address(Address target, 280 WriteBarrierMode mode = UPDATE_WRITE_BARRIER)); 281 INLINE(Object* target_object()); 282 INLINE(Handle<Object> target_object_handle(Assembler* origin)); 283 INLINE(Object** target_object_address()); 284 INLINE(void set_target_object(Object* target, 285 WriteBarrierMode mode = UPDATE_WRITE_BARRIER)); 286 INLINE(JSGlobalPropertyCell* target_cell()); 287 INLINE(Handle<JSGlobalPropertyCell> target_cell_handle()); 288 INLINE(void set_target_cell(JSGlobalPropertyCell* cell, 289 WriteBarrierMode mode = UPDATE_WRITE_BARRIER)); 290 291 292 // Read the address of the word containing the target_address in an 293 // instruction stream. What this means exactly is architecture-independent. 294 // The only architecture-independent user of this function is the serializer. 295 // The serializer uses it to find out how many raw bytes of instruction to 296 // output before the next target. Architecture-independent code shouldn't 297 // dereference the pointer it gets back from this. 298 INLINE(Address target_address_address()); 299 // This indicates how much space a target takes up when deserializing a code 300 // stream. For most architectures this is just the size of a pointer. For 301 // an instruction like movw/movt where the target bits are mixed into the 302 // instruction bits the size of the target will be zero, indicating that the 303 // serializer should not step forwards in memory after a target is resolved 304 // and written. In this case the target_address_address function above 305 // should return the end of the instructions to be patched, allowing the 306 // deserializer to deserialize the instructions as raw bytes and put them in 307 // place, ready to be patched with the target. 308 INLINE(int target_address_size()); 309 310 // Read/modify the reference in the instruction this relocation 311 // applies to; can only be called if rmode_ is external_reference 312 INLINE(Address* target_reference_address()); 313 314 // Read/modify the address of a call instruction. This is used to relocate 315 // the break points where straight-line code is patched with a call 316 // instruction. 317 INLINE(Address call_address()); 318 INLINE(void set_call_address(Address target)); 319 INLINE(Object* call_object()); 320 INLINE(void set_call_object(Object* target)); 321 INLINE(Object** call_object_address()); 322 323 template<typename StaticVisitor> inline void Visit(Heap* heap); 324 inline void Visit(ObjectVisitor* v); 325 326 // Patch the code with some other code. 327 void PatchCode(byte* instructions, int instruction_count); 328 329 // Patch the code with a call. 330 void PatchCodeWithCall(Address target, int guard_bytes); 331 332 // Check whether this return sequence has been patched 333 // with a call to the debugger. 334 INLINE(bool IsPatchedReturnSequence()); 335 336 // Check whether this debug break slot has been patched with a call to the 337 // debugger. 338 INLINE(bool IsPatchedDebugBreakSlotSequence()); 339 340#ifdef ENABLE_DISASSEMBLER 341 // Printing 342 static const char* RelocModeName(Mode rmode); 343 void Print(FILE* out); 344#endif // ENABLE_DISASSEMBLER 345#ifdef DEBUG 346 // Debugging 347 void Verify(); 348#endif 349 350 static const int kCodeTargetMask = (1 << (LAST_CODE_ENUM + 1)) - 1; 351 static const int kPositionMask = 1 << POSITION | 1 << STATEMENT_POSITION; 352 static const int kDataMask = 353 (1 << CODE_TARGET_WITH_ID) | kPositionMask | (1 << COMMENT); 354 static const int kApplyMask; // Modes affected by apply. Depends on arch. 355 356 private: 357 // On ARM, note that pc_ is the address of the constant pool entry 358 // to be relocated and not the address of the instruction 359 // referencing the constant pool entry (except when rmode_ == 360 // comment). 361 byte* pc_; 362 Mode rmode_; 363 intptr_t data_; 364 Code* host_; 365#ifdef V8_TARGET_ARCH_MIPS 366 // Code and Embedded Object pointers in mips are stored split 367 // across two consecutive 32-bit instructions. Heap management 368 // routines expect to access these pointers indirectly. The following 369 // location provides a place for these pointers to exist natually 370 // when accessed via the Iterator. 371 Object* reconstructed_obj_ptr_; 372 // External-reference pointers are also split across instruction-pairs 373 // in mips, but are accessed via indirect pointers. This location 374 // provides a place for that pointer to exist naturally. Its address 375 // is returned by RelocInfo::target_reference_address(). 376 Address reconstructed_adr_ptr_; 377#endif // V8_TARGET_ARCH_MIPS 378 friend class RelocIterator; 379}; 380 381 382// RelocInfoWriter serializes a stream of relocation info. It writes towards 383// lower addresses. 384class RelocInfoWriter BASE_EMBEDDED { 385 public: 386 RelocInfoWriter() : pos_(NULL), 387 last_pc_(NULL), 388 last_id_(0), 389 last_position_(0) {} 390 RelocInfoWriter(byte* pos, byte* pc) : pos_(pos), 391 last_pc_(pc), 392 last_id_(0), 393 last_position_(0) {} 394 395 byte* pos() const { return pos_; } 396 byte* last_pc() const { return last_pc_; } 397 398 void Write(const RelocInfo* rinfo); 399 400 // Update the state of the stream after reloc info buffer 401 // and/or code is moved while the stream is active. 402 void Reposition(byte* pos, byte* pc) { 403 pos_ = pos; 404 last_pc_ = pc; 405 } 406 407 // Max size (bytes) of a written RelocInfo. Longest encoding is 408 // ExtraTag, VariableLengthPCJump, ExtraTag, pc_delta, ExtraTag, data_delta. 409 // On ia32 and arm this is 1 + 4 + 1 + 1 + 1 + 4 = 12. 410 // On x64 this is 1 + 4 + 1 + 1 + 1 + 8 == 16; 411 // Here we use the maximum of the two. 412 static const int kMaxSize = 16; 413 414 private: 415 inline uint32_t WriteVariableLengthPCJump(uint32_t pc_delta); 416 inline void WriteTaggedPC(uint32_t pc_delta, int tag); 417 inline void WriteExtraTaggedPC(uint32_t pc_delta, int extra_tag); 418 inline void WriteExtraTaggedIntData(int data_delta, int top_tag); 419 inline void WriteExtraTaggedData(intptr_t data_delta, int top_tag); 420 inline void WriteTaggedData(intptr_t data_delta, int tag); 421 inline void WriteExtraTag(int extra_tag, int top_tag); 422 423 byte* pos_; 424 byte* last_pc_; 425 int last_id_; 426 int last_position_; 427 DISALLOW_COPY_AND_ASSIGN(RelocInfoWriter); 428}; 429 430 431// A RelocIterator iterates over relocation information. 432// Typical use: 433// 434// for (RelocIterator it(code); !it.done(); it.next()) { 435// // do something with it.rinfo() here 436// } 437// 438// A mask can be specified to skip unwanted modes. 439class RelocIterator: public Malloced { 440 public: 441 // Create a new iterator positioned at 442 // the beginning of the reloc info. 443 // Relocation information with mode k is included in the 444 // iteration iff bit k of mode_mask is set. 445 explicit RelocIterator(Code* code, int mode_mask = -1); 446 explicit RelocIterator(const CodeDesc& desc, int mode_mask = -1); 447 448 // Iteration 449 bool done() const { return done_; } 450 void next(); 451 452 // Return pointer valid until next next(). 453 RelocInfo* rinfo() { 454 ASSERT(!done()); 455 return &rinfo_; 456 } 457 458 private: 459 // Advance* moves the position before/after reading. 460 // *Read* reads from current byte(s) into rinfo_. 461 // *Get* just reads and returns info on current byte. 462 void Advance(int bytes = 1) { pos_ -= bytes; } 463 int AdvanceGetTag(); 464 int GetExtraTag(); 465 int GetTopTag(); 466 void ReadTaggedPC(); 467 void AdvanceReadPC(); 468 void AdvanceReadId(); 469 void AdvanceReadPosition(); 470 void AdvanceReadData(); 471 void AdvanceReadVariableLengthPCJump(); 472 int GetLocatableTypeTag(); 473 void ReadTaggedId(); 474 void ReadTaggedPosition(); 475 476 // If the given mode is wanted, set it in rinfo_ and return true. 477 // Else return false. Used for efficiently skipping unwanted modes. 478 bool SetMode(RelocInfo::Mode mode) { 479 return (mode_mask_ & (1 << mode)) ? (rinfo_.rmode_ = mode, true) : false; 480 } 481 482 byte* pos_; 483 byte* end_; 484 RelocInfo rinfo_; 485 bool done_; 486 int mode_mask_; 487 int last_id_; 488 int last_position_; 489 DISALLOW_COPY_AND_ASSIGN(RelocIterator); 490}; 491 492 493//------------------------------------------------------------------------------ 494// External function 495 496//---------------------------------------------------------------------------- 497class IC_Utility; 498class SCTableReference; 499#ifdef ENABLE_DEBUGGER_SUPPORT 500class Debug_Address; 501#endif 502 503 504// An ExternalReference represents a C++ address used in the generated 505// code. All references to C++ functions and variables must be encapsulated in 506// an ExternalReference instance. This is done in order to track the origin of 507// all external references in the code so that they can be bound to the correct 508// addresses when deserializing a heap. 509class ExternalReference BASE_EMBEDDED { 510 public: 511 // Used in the simulator to support different native api calls. 512 enum Type { 513 // Builtin call. 514 // MaybeObject* f(v8::internal::Arguments). 515 BUILTIN_CALL, // default 516 517 // Builtin that takes float arguments and returns an int. 518 // int f(double, double). 519 BUILTIN_COMPARE_CALL, 520 521 // Builtin call that returns floating point. 522 // double f(double, double). 523 BUILTIN_FP_FP_CALL, 524 525 // Builtin call that returns floating point. 526 // double f(double). 527 BUILTIN_FP_CALL, 528 529 // Builtin call that returns floating point. 530 // double f(double, int). 531 BUILTIN_FP_INT_CALL, 532 533 // Direct call to API function callback. 534 // Handle<Value> f(v8::Arguments&) 535 DIRECT_API_CALL, 536 537 // Direct call to accessor getter callback. 538 // Handle<value> f(Local<String> property, AccessorInfo& info) 539 DIRECT_GETTER_CALL 540 }; 541 542 typedef void* ExternalReferenceRedirector(void* original, Type type); 543 544 ExternalReference(Builtins::CFunctionId id, Isolate* isolate); 545 546 ExternalReference(ApiFunction* ptr, Type type, Isolate* isolate); 547 548 ExternalReference(Builtins::Name name, Isolate* isolate); 549 550 ExternalReference(Runtime::FunctionId id, Isolate* isolate); 551 552 ExternalReference(const Runtime::Function* f, Isolate* isolate); 553 554 ExternalReference(const IC_Utility& ic_utility, Isolate* isolate); 555 556#ifdef ENABLE_DEBUGGER_SUPPORT 557 ExternalReference(const Debug_Address& debug_address, Isolate* isolate); 558#endif 559 560 explicit ExternalReference(StatsCounter* counter); 561 562 ExternalReference(Isolate::AddressId id, Isolate* isolate); 563 564 explicit ExternalReference(const SCTableReference& table_ref); 565 566 // Isolate::Current() as an external reference. 567 static ExternalReference isolate_address(); 568 569 // One-of-a-kind references. These references are not part of a general 570 // pattern. This means that they have to be added to the 571 // ExternalReferenceTable in serialize.cc manually. 572 573 static ExternalReference incremental_marking_record_write_function( 574 Isolate* isolate); 575 static ExternalReference incremental_evacuation_record_write_function( 576 Isolate* isolate); 577 static ExternalReference store_buffer_overflow_function( 578 Isolate* isolate); 579 static ExternalReference flush_icache_function(Isolate* isolate); 580 static ExternalReference perform_gc_function(Isolate* isolate); 581 static ExternalReference fill_heap_number_with_random_function( 582 Isolate* isolate); 583 static ExternalReference random_uint32_function(Isolate* isolate); 584 static ExternalReference transcendental_cache_array_address(Isolate* isolate); 585 static ExternalReference delete_handle_scope_extensions(Isolate* isolate); 586 587 static ExternalReference get_date_field_function(Isolate* isolate); 588 static ExternalReference date_cache_stamp(Isolate* isolate); 589 590 // Deoptimization support. 591 static ExternalReference new_deoptimizer_function(Isolate* isolate); 592 static ExternalReference compute_output_frames_function(Isolate* isolate); 593 594 // Static data in the keyed lookup cache. 595 static ExternalReference keyed_lookup_cache_keys(Isolate* isolate); 596 static ExternalReference keyed_lookup_cache_field_offsets(Isolate* isolate); 597 598 // Static variable Heap::roots_array_start() 599 static ExternalReference roots_array_start(Isolate* isolate); 600 601 // Static variable StackGuard::address_of_jslimit() 602 static ExternalReference address_of_stack_limit(Isolate* isolate); 603 604 // Static variable StackGuard::address_of_real_jslimit() 605 static ExternalReference address_of_real_stack_limit(Isolate* isolate); 606 607 // Static variable RegExpStack::limit_address() 608 static ExternalReference address_of_regexp_stack_limit(Isolate* isolate); 609 610 // Static variables for RegExp. 611 static ExternalReference address_of_static_offsets_vector(Isolate* isolate); 612 static ExternalReference address_of_regexp_stack_memory_address( 613 Isolate* isolate); 614 static ExternalReference address_of_regexp_stack_memory_size( 615 Isolate* isolate); 616 617 // Static variable Heap::NewSpaceStart() 618 static ExternalReference new_space_start(Isolate* isolate); 619 static ExternalReference new_space_mask(Isolate* isolate); 620 static ExternalReference heap_always_allocate_scope_depth(Isolate* isolate); 621 static ExternalReference new_space_mark_bits(Isolate* isolate); 622 623 // Write barrier. 624 static ExternalReference store_buffer_top(Isolate* isolate); 625 626 // Used for fast allocation in generated code. 627 static ExternalReference new_space_allocation_top_address(Isolate* isolate); 628 static ExternalReference new_space_allocation_limit_address(Isolate* isolate); 629 630 static ExternalReference double_fp_operation(Token::Value operation, 631 Isolate* isolate); 632 static ExternalReference compare_doubles(Isolate* isolate); 633 static ExternalReference power_double_double_function(Isolate* isolate); 634 static ExternalReference power_double_int_function(Isolate* isolate); 635 636 static ExternalReference handle_scope_next_address(); 637 static ExternalReference handle_scope_limit_address(); 638 static ExternalReference handle_scope_level_address(); 639 640 static ExternalReference scheduled_exception_address(Isolate* isolate); 641 642 // Static variables containing common double constants. 643 static ExternalReference address_of_min_int(); 644 static ExternalReference address_of_one_half(); 645 static ExternalReference address_of_minus_zero(); 646 static ExternalReference address_of_zero(); 647 static ExternalReference address_of_uint8_max_value(); 648 static ExternalReference address_of_negative_infinity(); 649 static ExternalReference address_of_canonical_non_hole_nan(); 650 static ExternalReference address_of_the_hole_nan(); 651 652 static ExternalReference math_sin_double_function(Isolate* isolate); 653 static ExternalReference math_cos_double_function(Isolate* isolate); 654 static ExternalReference math_tan_double_function(Isolate* isolate); 655 static ExternalReference math_log_double_function(Isolate* isolate); 656 657 Address address() const {return reinterpret_cast<Address>(address_);} 658 659#ifdef ENABLE_DEBUGGER_SUPPORT 660 // Function Debug::Break() 661 static ExternalReference debug_break(Isolate* isolate); 662 663 // Used to check if single stepping is enabled in generated code. 664 static ExternalReference debug_step_in_fp_address(Isolate* isolate); 665#endif 666 667#ifndef V8_INTERPRETED_REGEXP 668 // C functions called from RegExp generated code. 669 670 // Function NativeRegExpMacroAssembler::CaseInsensitiveCompareUC16() 671 static ExternalReference re_case_insensitive_compare_uc16(Isolate* isolate); 672 673 // Function RegExpMacroAssembler*::CheckStackGuardState() 674 static ExternalReference re_check_stack_guard_state(Isolate* isolate); 675 676 // Function NativeRegExpMacroAssembler::GrowStack() 677 static ExternalReference re_grow_stack(Isolate* isolate); 678 679 // byte NativeRegExpMacroAssembler::word_character_bitmap 680 static ExternalReference re_word_character_map(); 681 682#endif 683 684 // This lets you register a function that rewrites all external references. 685 // Used by the ARM simulator to catch calls to external references. 686 static void set_redirector(Isolate* isolate, 687 ExternalReferenceRedirector* redirector) { 688 // We can't stack them. 689 ASSERT(isolate->external_reference_redirector() == NULL); 690 isolate->set_external_reference_redirector( 691 reinterpret_cast<ExternalReferenceRedirectorPointer*>(redirector)); 692 } 693 694 private: 695 explicit ExternalReference(void* address) 696 : address_(address) {} 697 698 static void* Redirect(Isolate* isolate, 699 void* address, 700 Type type = ExternalReference::BUILTIN_CALL) { 701 ExternalReferenceRedirector* redirector = 702 reinterpret_cast<ExternalReferenceRedirector*>( 703 isolate->external_reference_redirector()); 704 if (redirector == NULL) return address; 705 void* answer = (*redirector)(address, type); 706 return answer; 707 } 708 709 static void* Redirect(Isolate* isolate, 710 Address address_arg, 711 Type type = ExternalReference::BUILTIN_CALL) { 712 ExternalReferenceRedirector* redirector = 713 reinterpret_cast<ExternalReferenceRedirector*>( 714 isolate->external_reference_redirector()); 715 void* address = reinterpret_cast<void*>(address_arg); 716 void* answer = (redirector == NULL) ? 717 address : 718 (*redirector)(address, type); 719 return answer; 720 } 721 722 void* address_; 723}; 724 725 726// ----------------------------------------------------------------------------- 727// Position recording support 728 729struct PositionState { 730 PositionState() : current_position(RelocInfo::kNoPosition), 731 written_position(RelocInfo::kNoPosition), 732 current_statement_position(RelocInfo::kNoPosition), 733 written_statement_position(RelocInfo::kNoPosition) {} 734 735 int current_position; 736 int written_position; 737 738 int current_statement_position; 739 int written_statement_position; 740}; 741 742 743class PositionsRecorder BASE_EMBEDDED { 744 public: 745 explicit PositionsRecorder(Assembler* assembler) 746 : assembler_(assembler) { 747#ifdef ENABLE_GDB_JIT_INTERFACE 748 gdbjit_lineinfo_ = NULL; 749#endif 750 } 751 752#ifdef ENABLE_GDB_JIT_INTERFACE 753 ~PositionsRecorder() { 754 delete gdbjit_lineinfo_; 755 } 756 757 void StartGDBJITLineInfoRecording() { 758 if (FLAG_gdbjit) { 759 gdbjit_lineinfo_ = new GDBJITLineInfo(); 760 } 761 } 762 763 GDBJITLineInfo* DetachGDBJITLineInfo() { 764 GDBJITLineInfo* lineinfo = gdbjit_lineinfo_; 765 gdbjit_lineinfo_ = NULL; // To prevent deallocation in destructor. 766 return lineinfo; 767 } 768#endif 769 770 // Set current position to pos. 771 void RecordPosition(int pos); 772 773 // Set current statement position to pos. 774 void RecordStatementPosition(int pos); 775 776 // Write recorded positions to relocation information. 777 bool WriteRecordedPositions(); 778 779 int current_position() const { return state_.current_position; } 780 781 int current_statement_position() const { 782 return state_.current_statement_position; 783 } 784 785 private: 786 Assembler* assembler_; 787 PositionState state_; 788#ifdef ENABLE_GDB_JIT_INTERFACE 789 GDBJITLineInfo* gdbjit_lineinfo_; 790#endif 791 792 friend class PreservePositionScope; 793 794 DISALLOW_COPY_AND_ASSIGN(PositionsRecorder); 795}; 796 797 798class PreservePositionScope BASE_EMBEDDED { 799 public: 800 explicit PreservePositionScope(PositionsRecorder* positions_recorder) 801 : positions_recorder_(positions_recorder), 802 saved_state_(positions_recorder->state_) {} 803 804 ~PreservePositionScope() { 805 positions_recorder_->state_ = saved_state_; 806 } 807 808 private: 809 PositionsRecorder* positions_recorder_; 810 const PositionState saved_state_; 811 812 DISALLOW_COPY_AND_ASSIGN(PreservePositionScope); 813}; 814 815 816// ----------------------------------------------------------------------------- 817// Utility functions 818 819inline bool is_intn(int x, int n) { 820 return -(1 << (n-1)) <= x && x < (1 << (n-1)); 821} 822 823inline bool is_int8(int x) { return is_intn(x, 8); } 824inline bool is_int16(int x) { return is_intn(x, 16); } 825inline bool is_int18(int x) { return is_intn(x, 18); } 826inline bool is_int24(int x) { return is_intn(x, 24); } 827 828inline bool is_uintn(int x, int n) { 829 return (x & -(1 << n)) == 0; 830} 831 832inline bool is_uint2(int x) { return is_uintn(x, 2); } 833inline bool is_uint3(int x) { return is_uintn(x, 3); } 834inline bool is_uint4(int x) { return is_uintn(x, 4); } 835inline bool is_uint5(int x) { return is_uintn(x, 5); } 836inline bool is_uint6(int x) { return is_uintn(x, 6); } 837inline bool is_uint8(int x) { return is_uintn(x, 8); } 838inline bool is_uint10(int x) { return is_uintn(x, 10); } 839inline bool is_uint12(int x) { return is_uintn(x, 12); } 840inline bool is_uint16(int x) { return is_uintn(x, 16); } 841inline bool is_uint24(int x) { return is_uintn(x, 24); } 842inline bool is_uint26(int x) { return is_uintn(x, 26); } 843inline bool is_uint28(int x) { return is_uintn(x, 28); } 844 845inline int NumberOfBitsSet(uint32_t x) { 846 unsigned int num_bits_set; 847 for (num_bits_set = 0; x; x >>= 1) { 848 num_bits_set += x & 1; 849 } 850 return num_bits_set; 851} 852 853bool EvalComparison(Token::Value op, double op1, double op2); 854 855// Computes pow(x, y) with the special cases in the spec for Math.pow. 856double power_double_int(double x, int y); 857double power_double_double(double x, double y); 858 859// Helper class for generating code or data associated with the code 860// right after a call instruction. As an example this can be used to 861// generate safepoint data after calls for crankshaft. 862class CallWrapper { 863 public: 864 CallWrapper() { } 865 virtual ~CallWrapper() { } 866 // Called just before emitting a call. Argument is the size of the generated 867 // call code. 868 virtual void BeforeCall(int call_size) const = 0; 869 // Called just after emitting a call, i.e., at the return site for the call. 870 virtual void AfterCall() const = 0; 871}; 872 873class NullCallWrapper : public CallWrapper { 874 public: 875 NullCallWrapper() { } 876 virtual ~NullCallWrapper() { } 877 virtual void BeforeCall(int call_size) const { } 878 virtual void AfterCall() const { } 879}; 880 881} } // namespace v8::internal 882 883#endif // V8_ASSEMBLER_H_ 884