src/v8/src/assembler.h

   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 "src/v8.h"
  39
  40 #include "src/allocation.h"
  41 #include "src/builtins.h"
  42 #include "src/gdb-jit.h"
  43 #include "src/isolate.h"
  44 #include "src/runtime/runtime.h"
  45 #include "src/token.h"
  46
  47 namespace v8 {
  48
  49 class ApiFunction;
  50
  51 namespace internal {
  52
  53 class StatsCounter;
  54 // -----------------------------------------------------------------------------
  55 // Platform independent assembler base class.
  56
  57 class AssemblerBase: public Malloced {
  58  public:
  59   AssemblerBase(Isolate* isolate, void* buffer, int buffer_size);
  60   virtual ~AssemblerBase();
  61
  62   Isolate* isolate() const { return isolate_; }
  63   int jit_cookie() const { return jit_cookie_; }
  64
  65   bool emit_debug_code() const { return emit_debug_code_; }
  66   void set_emit_debug_code(bool value) { emit_debug_code_ = value; }
  67
  68   bool serializer_enabled() const { return serializer_enabled_; }
  69   void enable_serializer() { serializer_enabled_ = true; }
  70
  71   bool predictable_code_size() const { return predictable_code_size_; }
  72   void set_predictable_code_size(bool value) { predictable_code_size_ = value; }
  73
  74   uint64_t enabled_cpu_features() const { return enabled_cpu_features_; }
  75   void set_enabled_cpu_features(uint64_t features) {
  76     enabled_cpu_features_ = features;
  77   }
  78   bool IsEnabled(CpuFeature f) {
  79     return (enabled_cpu_features_ & (static_cast<uint64_t>(1) << f)) != 0;
  80   }
  81
  82   bool is_ool_constant_pool_available() const {
  83     if (FLAG_enable_ool_constant_pool) {
  84       return ool_constant_pool_available_;
  85     } else {
  86       // Out-of-line constant pool not supported on this architecture.
  87       UNREACHABLE();
  88       return false;
  89     }
  90   }
  91
  92   // Overwrite a host NaN with a quiet target NaN.  Used by mksnapshot for
  93   // cross-snapshotting.
  94   static void QuietNaN(HeapObject* nan) { }
  95
  96   int pc_offset() const { return static_cast<int>(pc_ - buffer_); }
  97
  98   // This function is called when code generation is aborted, so that
  99   // the assembler could clean up internal data structures.
 100   virtual void AbortedCodeGeneration() { }
 101
 102   static const int kMinimalBufferSize = 4*KB;
 103
 104  protected:
 105   // The buffer into which code and relocation info are generated. It could
 106   // either be owned by the assembler or be provided externally.
 107   byte* buffer_;
 108   int buffer_size_;
 109   bool own_buffer_;
 110
 111   void set_ool_constant_pool_available(bool available) {
 112     if (FLAG_enable_ool_constant_pool) {
 113       ool_constant_pool_available_ = available;
 114     } else {
 115       // Out-of-line constant pool not supported on this architecture.
 116       UNREACHABLE();
 117     }
 118   }
 119
 120   // The program counter, which points into the buffer above and moves forward.
 121   byte* pc_;
 122
 123  private:
 124   Isolate* isolate_;
 125   int jit_cookie_;
 126   uint64_t enabled_cpu_features_;
 127   bool emit_debug_code_;
 128   bool predictable_code_size_;
 129   bool serializer_enabled_;
 130
 131   // Indicates whether the constant pool can be accessed, which is only possible
 132   // if the pp register points to the current code object's constant pool.
 133   bool ool_constant_pool_available_;
 134
 135   // Constant pool.
 136   friend class FrameAndConstantPoolScope;
 137   friend class ConstantPoolUnavailableScope;
 138 };
 139
 140
 141 // Avoids emitting debug code during the lifetime of this scope object.
 142 class DontEmitDebugCodeScope BASE_EMBEDDED {
 143  public:
 144   explicit DontEmitDebugCodeScope(AssemblerBase* assembler)
 145       : assembler_(assembler), old_value_(assembler->emit_debug_code()) {
 146     assembler_->set_emit_debug_code(false);
 147   }
 148   ~DontEmitDebugCodeScope() {
 149     assembler_->set_emit_debug_code(old_value_);
 150   }
 151  private:
 152   AssemblerBase* assembler_;
 153   bool old_value_;
 154 };
 155
 156
 157 // Avoids using instructions that vary in size in unpredictable ways between the
 158 // snapshot and the running VM.
 159 class PredictableCodeSizeScope {
 160  public:
 161   PredictableCodeSizeScope(AssemblerBase* assembler, int expected_size);
 162   ~PredictableCodeSizeScope();
 163
 164  private:
 165   AssemblerBase* assembler_;
 166   int expected_size_;
 167   int start_offset_;
 168   bool old_value_;
 169 };
 170
 171
 172 // Enable a specified feature within a scope.
 173 class CpuFeatureScope BASE_EMBEDDED {
 174  public:
 175 #ifdef DEBUG
 176   CpuFeatureScope(AssemblerBase* assembler, CpuFeature f);
 177   ~CpuFeatureScope();
 178
 179  private:
 180   AssemblerBase* assembler_;
 181   uint64_t old_enabled_;
 182 #else
 183   CpuFeatureScope(AssemblerBase* assembler, CpuFeature f) {}
 184 #endif
 185 };
 186
 187
 188 // CpuFeatures keeps track of which features are supported by the target CPU.
 189 // Supported features must be enabled by a CpuFeatureScope before use.
 190 // Example:
 191 //   if (assembler->IsSupported(SSE3)) {
 192 //     CpuFeatureScope fscope(assembler, SSE3);
 193 //     // Generate code containing SSE3 instructions.
 194 //   } else {
 195 //     // Generate alternative code.
 196 //   }
 197 class CpuFeatures : public AllStatic {
 198  public:
 199   static void Probe(bool cross_compile) {
 200     STATIC_ASSERT(NUMBER_OF_CPU_FEATURES <= kBitsPerInt);
 201     if (initialized_) return;
 202     initialized_ = true;
 203     ProbeImpl(cross_compile);
 204   }
 205
 206   static unsigned SupportedFeatures() {
 207     Probe(false);
 208     return supported_;
 209   }
 210
 211   static bool IsSupported(CpuFeature f) {
 212     return (supported_ & (1u << f)) != 0;
 213   }
 214
 215   static inline bool SupportsCrankshaft();
 216
 217   static inline unsigned cache_line_size() {
 218     DCHECK(cache_line_size_ != 0);
 219     return cache_line_size_;
 220   }
 221
 222   static void PrintTarget();
 223   static void PrintFeatures();
 224
 225   // Flush instruction cache.
 226   static void FlushICache(void* start, size_t size);
 227
 228  private:
 229   // Platform-dependent implementation.
 230   static void ProbeImpl(bool cross_compile);
 231
 232   static unsigned supported_;
 233   static unsigned cache_line_size_;
 234   static bool initialized_;
 235   friend class ExternalReference;
 236   DISALLOW_COPY_AND_ASSIGN(CpuFeatures);
 237 };
 238
 239
 240 // -----------------------------------------------------------------------------
 241 // Labels represent pc locations; they are typically jump or call targets.
 242 // After declaration, a label can be freely used to denote known or (yet)
 243 // unknown pc location. Assembler::bind() is used to bind a label to the
 244 // current pc. A label can be bound only once.
 245
 246 class Label BASE_EMBEDDED {
 247  public:
 248   enum Distance {
 249     kNear, kFar
 250   };
 251
 252   INLINE(Label()) {
 253     Unuse();
 254     UnuseNear();
 255   }
 256
 257   INLINE(~Label()) {
 258     DCHECK(!is_linked());
 259     DCHECK(!is_near_linked());
 260   }
 261
 262   INLINE(void Unuse()) { pos_ = 0; }
 263   INLINE(void UnuseNear()) { near_link_pos_ = 0; }
 264
 265   INLINE(bool is_bound() const) { return pos_ <  0; }
 266   INLINE(bool is_unused() const) { return pos_ == 0 && near_link_pos_ == 0; }
 267   INLINE(bool is_linked() const) { return pos_ >  0; }
 268   INLINE(bool is_near_linked() const) { return near_link_pos_ > 0; }
 269
 270   // Returns the position of bound or linked labels. Cannot be used
 271   // for unused labels.
 272   int pos() const;
 273   int near_link_pos() const { return near_link_pos_ - 1; }
 274
 275  private:
 276   // pos_ encodes both the binding state (via its sign)
 277   // and the binding position (via its value) of a label.
 278   //
 279   // pos_ <  0  bound label, pos() returns the jump target position
 280   // pos_ == 0  unused label
 281   // pos_ >  0  linked label, pos() returns the last reference position
 282   int pos_;
 283
 284   // Behaves like |pos_| in the "> 0" case, but for near jumps to this label.
 285   int near_link_pos_;
 286
 287   void bind_to(int pos)  {
 288     pos_ = -pos - 1;
 289     DCHECK(is_bound());
 290   }
 291   void link_to(int pos, Distance distance = kFar) {
 292     if (distance == kNear) {
 293       near_link_pos_ = pos + 1;
 294       DCHECK(is_near_linked());
 295     } else {
 296       pos_ = pos + 1;
 297       DCHECK(is_linked());
 298     }
 299   }
 300
 301   friend class Assembler;
 302   friend class Displacement;
 303   friend class RegExpMacroAssemblerIrregexp;
 304
 305 #if V8_TARGET_ARCH_ARM64
 306   // On ARM64, the Assembler keeps track of pointers to Labels to resolve
 307   // branches to distant targets. Copying labels would confuse the Assembler.
 308   DISALLOW_COPY_AND_ASSIGN(Label);  // NOLINT
 309 #endif
 310 };
 311
 312
 313 enum SaveFPRegsMode { kDontSaveFPRegs, kSaveFPRegs };
 314
 315 // Specifies whether to perform icache flush operations on RelocInfo updates.
 316 // If FLUSH_ICACHE_IF_NEEDED, the icache will always be flushed if an
 317 // instruction was modified. If SKIP_ICACHE_FLUSH the flush will always be
 318 // skipped (only use this if you will flush the icache manually before it is
 319 // executed).
 320 enum ICacheFlushMode { FLUSH_ICACHE_IF_NEEDED, SKIP_ICACHE_FLUSH };
 321
 322 // -----------------------------------------------------------------------------
 323 // Relocation information
 324
 325
 326 // Relocation information consists of the address (pc) of the datum
 327 // to which the relocation information applies, the relocation mode
 328 // (rmode), and an optional data field. The relocation mode may be
 329 // "descriptive" and not indicate a need for relocation, but simply
 330 // describe a property of the datum. Such rmodes are useful for GC
 331 // and nice disassembly output.
 332
 333 class RelocInfo {
 334  public:
 335   // The constant kNoPosition is used with the collecting of source positions
 336   // in the relocation information. Two types of source positions are collected
 337   // "position" (RelocMode position) and "statement position" (RelocMode
 338   // statement_position). The "position" is collected at places in the source
 339   // code which are of interest when making stack traces to pin-point the source
 340   // location of a stack frame as close as possible. The "statement position" is
 341   // collected at the beginning at each statement, and is used to indicate
 342   // possible break locations. kNoPosition is used to indicate an
 343   // invalid/uninitialized position value.
 344   static const int kNoPosition = -1;
 345
 346   // This string is used to add padding comments to the reloc info in cases
 347   // where we are not sure to have enough space for patching in during
 348   // lazy deoptimization. This is the case if we have indirect calls for which
 349   // we do not normally record relocation info.
 350   static const char* const kFillerCommentString;
 351
 352   // The minimum size of a comment is equal to three bytes for the extra tagged
 353   // pc + the tag for the data, and kPointerSize for the actual pointer to the
 354   // comment.
 355   static const int kMinRelocCommentSize = 3 + kPointerSize;
 356
 357   // The maximum size for a call instruction including pc-jump.
 358   static const int kMaxCallSize = 6;
 359
 360   // The maximum pc delta that will use the short encoding.
 361   static const int kMaxSmallPCDelta;
 362
 363   enum Mode {
 364     // Please note the order is important (see IsCodeTarget, IsGCRelocMode).
 365     CODE_TARGET,  // Code target which is not any of the above.
 366     CODE_TARGET_WITH_ID,
 367     CONSTRUCT_CALL,  // code target that is a call to a JavaScript constructor.
 368     DEBUG_BREAK,  // Code target for the debugger statement.
 369     EMBEDDED_OBJECT,
 370     CELL,
 371
 372     // Everything after runtime_entry (inclusive) is not GC'ed.
 373     RUNTIME_ENTRY,
 374     JS_RETURN,  // Marks start of the ExitJSFrame code.
 375     COMMENT,
 376     POSITION,  // See comment for kNoPosition above.
 377     STATEMENT_POSITION,  // See comment for kNoPosition above.
 378     DEBUG_BREAK_SLOT,  // Additional code inserted for debug break slot.
 379     EXTERNAL_REFERENCE,  // The address of an external C++ function.
 380     INTERNAL_REFERENCE,  // An address inside the same function.
 381
 382     // Marks constant and veneer pools. Only used on ARM and ARM64.
 383     // They use a custom noncompact encoding.
 384     CONST_POOL,
 385     VENEER_POOL,
 386
 387     // add more as needed
 388     // Pseudo-types
 389     NUMBER_OF_MODES,  // There are at most 15 modes with noncompact encoding.
 390     NONE32,  // never recorded 32-bit value
 391     NONE64,  // never recorded 64-bit value
 392     CODE_AGE_SEQUENCE,  // Not stored in RelocInfo array, used explictly by
 393                         // code aging.
 394     FIRST_REAL_RELOC_MODE = CODE_TARGET,
 395     LAST_REAL_RELOC_MODE = VENEER_POOL,
 396     FIRST_PSEUDO_RELOC_MODE = CODE_AGE_SEQUENCE,
 397     LAST_PSEUDO_RELOC_MODE = CODE_AGE_SEQUENCE,
 398     LAST_CODE_ENUM = DEBUG_BREAK,
 399     LAST_GCED_ENUM = CELL,
 400     // Modes <= LAST_COMPACT_ENUM are guaranteed to have compact encoding.
 401     LAST_COMPACT_ENUM = CODE_TARGET_WITH_ID,
 402     LAST_STANDARD_NONCOMPACT_ENUM = INTERNAL_REFERENCE
 403   };
 404
 405   RelocInfo() {}
 406
 407   RelocInfo(byte* pc, Mode rmode, intptr_t data, Code* host)
 408       : pc_(pc), rmode_(rmode), data_(data), host_(host) {
 409   }
 410   RelocInfo(byte* pc, double data64)
 411       : pc_(pc), rmode_(NONE64), data64_(data64), host_(NULL) {
 412   }
 413
 414   static inline bool IsRealRelocMode(Mode mode) {
 415     return mode >= FIRST_REAL_RELOC_MODE &&
 416         mode <= LAST_REAL_RELOC_MODE;
 417   }
 418   static inline bool IsPseudoRelocMode(Mode mode) {
 419     DCHECK(!IsRealRelocMode(mode));
 420     return mode >= FIRST_PSEUDO_RELOC_MODE &&
 421         mode <= LAST_PSEUDO_RELOC_MODE;
 422   }
 423   static inline bool IsConstructCall(Mode mode) {
 424     return mode == CONSTRUCT_CALL;
 425   }
 426   static inline bool IsCodeTarget(Mode mode) {
 427     return mode <= LAST_CODE_ENUM;
 428   }
 429   static inline bool IsEmbeddedObject(Mode mode) {
 430     return mode == EMBEDDED_OBJECT;
 431   }
 432   static inline bool IsRuntimeEntry(Mode mode) {
 433     return mode == RUNTIME_ENTRY;
 434   }
 435   // Is the relocation mode affected by GC?
 436   static inline bool IsGCRelocMode(Mode mode) {
 437     return mode <= LAST_GCED_ENUM;
 438   }
 439   static inline bool IsJSReturn(Mode mode) {
 440     return mode == JS_RETURN;
 441   }
 442   static inline bool IsComment(Mode mode) {
 443     return mode == COMMENT;
 444   }
 445   static inline bool IsConstPool(Mode mode) {
 446     return mode == CONST_POOL;
 447   }
 448   static inline bool IsVeneerPool(Mode mode) {
 449     return mode == VENEER_POOL;
 450   }
 451   static inline bool IsPosition(Mode mode) {
 452     return mode == POSITION || mode == STATEMENT_POSITION;
 453   }
 454   static inline bool IsStatementPosition(Mode mode) {
 455     return mode == STATEMENT_POSITION;
 456   }
 457   static inline bool IsExternalReference(Mode mode) {
 458     return mode == EXTERNAL_REFERENCE;
 459   }
 460   static inline bool IsInternalReference(Mode mode) {
 461     return mode == INTERNAL_REFERENCE;
 462   }
 463   static inline bool IsDebugBreakSlot(Mode mode) {
 464     return mode == DEBUG_BREAK_SLOT;
 465   }
 466   static inline bool IsNone(Mode mode) {
 467     return mode == NONE32 || mode == NONE64;
 468   }
 469   static inline bool IsCodeAgeSequence(Mode mode) {
 470     return mode == CODE_AGE_SEQUENCE;
 471   }
 472   static inline int ModeMask(Mode mode) { return 1 << mode; }
 473
 474   // Returns true if the first RelocInfo has the same mode and raw data as the
 475   // second one.
 476   static inline bool IsEqual(RelocInfo first, RelocInfo second) {
 477     return first.rmode() == second.rmode() &&
 478            (first.rmode() == RelocInfo::NONE64 ?
 479               first.raw_data64() == second.raw_data64() :
 480               first.data() == second.data());
 481   }
 482
 483   // Accessors
 484   byte* pc() const { return pc_; }
 485   void set_pc(byte* pc) { pc_ = pc; }
 486   Mode rmode() const {  return rmode_; }
 487   intptr_t data() const { return data_; }
 488   double data64() const { return data64_; }
 489   uint64_t raw_data64() { return bit_cast<uint64_t>(data64_); }
 490   Code* host() const { return host_; }
 491   void set_host(Code* host) { host_ = host; }
 492
 493   // Apply a relocation by delta bytes
 494   INLINE(void apply(intptr_t delta,
 495                     ICacheFlushMode icache_flush_mode =
 496                         FLUSH_ICACHE_IF_NEEDED));
 497
 498   // Is the pointer this relocation info refers to coded like a plain pointer
 499   // or is it strange in some way (e.g. relative or patched into a series of
 500   // instructions).
 501   bool IsCodedSpecially();
 502
 503   // If true, the pointer this relocation info refers to is an entry in the
 504   // constant pool, otherwise the pointer is embedded in the instruction stream.
 505   bool IsInConstantPool();
 506
 507   // Read/modify the code target in the branch/call instruction
 508   // this relocation applies to;
 509   // can only be called if IsCodeTarget(rmode_) || IsRuntimeEntry(rmode_)
 510   INLINE(Address target_address());
 511   INLINE(void set_target_address(Address target,
 512                                  WriteBarrierMode write_barrier_mode =
 513                                      UPDATE_WRITE_BARRIER,
 514                                  ICacheFlushMode icache_flush_mode =
 515                                      FLUSH_ICACHE_IF_NEEDED));
 516   INLINE(Object* target_object());
 517   INLINE(Handle<Object> target_object_handle(Assembler* origin));
 518   INLINE(void set_target_object(Object* target,
 519                                 WriteBarrierMode write_barrier_mode =
 520                                     UPDATE_WRITE_BARRIER,
 521                                 ICacheFlushMode icache_flush_mode =
 522                                     FLUSH_ICACHE_IF_NEEDED));
 523   INLINE(Address target_runtime_entry(Assembler* origin));
 524   INLINE(void set_target_runtime_entry(Address target,
 525                                        WriteBarrierMode write_barrier_mode =
 526                                            UPDATE_WRITE_BARRIER,
 527                                        ICacheFlushMode icache_flush_mode =
 528                                            FLUSH_ICACHE_IF_NEEDED));
 529   INLINE(Cell* target_cell());
 530   INLINE(Handle<Cell> target_cell_handle());
 531   INLINE(void set_target_cell(Cell* cell,
 532                               WriteBarrierMode write_barrier_mode =
 533                                   UPDATE_WRITE_BARRIER,
 534                               ICacheFlushMode icache_flush_mode =
 535                                   FLUSH_ICACHE_IF_NEEDED));
 536   INLINE(Handle<Object> code_age_stub_handle(Assembler* origin));
 537   INLINE(Code* code_age_stub());
 538   INLINE(void set_code_age_stub(Code* stub,
 539                                 ICacheFlushMode icache_flush_mode =
 540                                     FLUSH_ICACHE_IF_NEEDED));
 541
 542   // Returns the address of the constant pool entry where the target address
 543   // is held.  This should only be called if IsInConstantPool returns true.
 544   INLINE(Address constant_pool_entry_address());
 545
 546   // Read the address of the word containing the target_address in an
 547   // instruction stream.  What this means exactly is architecture-independent.
 548   // The only architecture-independent user of this function is the serializer.
 549   // The serializer uses it to find out how many raw bytes of instruction to
 550   // output before the next target.  Architecture-independent code shouldn't
 551   // dereference the pointer it gets back from this.
 552   INLINE(Address target_address_address());
 553
 554   // This indicates how much space a target takes up when deserializing a code
 555   // stream.  For most architectures this is just the size of a pointer.  For
 556   // an instruction like movw/movt where the target bits are mixed into the
 557   // instruction bits the size of the target will be zero, indicating that the
 558   // serializer should not step forwards in memory after a target is resolved
 559   // and written.  In this case the target_address_address function above
 560   // should return the end of the instructions to be patched, allowing the
 561   // deserializer to deserialize the instructions as raw bytes and put them in
 562   // place, ready to be patched with the target.
 563   INLINE(int target_address_size());
 564
 565   // Read/modify the reference in the instruction this relocation
 566   // applies to; can only be called if rmode_ is external_reference
 567   INLINE(Address target_reference());
 568
 569   // Read/modify the address of a call instruction. This is used to relocate
 570   // the break points where straight-line code is patched with a call
 571   // instruction.
 572   INLINE(Address call_address());
 573   INLINE(void set_call_address(Address target));
 574   INLINE(Object* call_object());
 575   INLINE(void set_call_object(Object* target));
 576   INLINE(Object** call_object_address());
 577
 578   // Wipe out a relocation to a fixed value, used for making snapshots
 579   // reproducible.
 580   INLINE(void WipeOut());
 581
 582   template<typename StaticVisitor> inline void Visit(Heap* heap);
 583   inline void Visit(Isolate* isolate, ObjectVisitor* v);
 584
 585   // Patch the code with some other code.
 586   void PatchCode(byte* instructions, int instruction_count);
 587
 588   // Patch the code with a call.
 589   void PatchCodeWithCall(Address target, int guard_bytes);
 590
 591   // Check whether this return sequence has been patched
 592   // with a call to the debugger.
 593   INLINE(bool IsPatchedReturnSequence());
 594
 595   // Check whether this debug break slot has been patched with a call to the
 596   // debugger.
 597   INLINE(bool IsPatchedDebugBreakSlotSequence());
 598
 599 #ifdef DEBUG
 600   // Check whether the given code contains relocation information that
 601   // either is position-relative or movable by the garbage collector.
 602   static bool RequiresRelocation(const CodeDesc& desc);
 603 #endif
 604
 605 #ifdef ENABLE_DISASSEMBLER
 606   // Printing
 607   static const char* RelocModeName(Mode rmode);
 608   void Print(Isolate* isolate, std::ostream& os);  // NOLINT
 609 #endif  // ENABLE_DISASSEMBLER
 610 #ifdef VERIFY_HEAP
 611   void Verify(Isolate* isolate);
 612 #endif
 613
 614   static const int kCodeTargetMask = (1 << (LAST_CODE_ENUM + 1)) - 1;
 615   static const int kPositionMask = 1 << POSITION | 1 << STATEMENT_POSITION;
 616   static const int kDataMask =
 617       (1 << CODE_TARGET_WITH_ID) | kPositionMask | (1 << COMMENT);
 618   static const int kApplyMask;  // Modes affected by apply. Depends on arch.
 619
 620  private:
 621   // On ARM, note that pc_ is the address of the constant pool entry
 622   // to be relocated and not the address of the instruction
 623   // referencing the constant pool entry (except when rmode_ ==
 624   // comment).
 625   byte* pc_;
 626   Mode rmode_;
 627   union {
 628     intptr_t data_;
 629     double data64_;
 630   };
 631   Code* host_;
 632   // External-reference pointers are also split across instruction-pairs
 633   // on some platforms, but are accessed via indirect pointers. This location
 634   // provides a place for that pointer to exist naturally. Its address
 635   // is returned by RelocInfo::target_reference_address().
 636   Address reconstructed_adr_ptr_;
 637   friend class RelocIterator;
 638 };
 639
 640
 641 // RelocInfoWriter serializes a stream of relocation info. It writes towards
 642 // lower addresses.
 643 class RelocInfoWriter BASE_EMBEDDED {
 644  public:
 645   RelocInfoWriter() : pos_(NULL),
 646                       last_pc_(NULL),
 647                       last_id_(0),
 648                       last_position_(0) {}
 649   RelocInfoWriter(byte* pos, byte* pc) : pos_(pos),
 650                                          last_pc_(pc),
 651                                          last_id_(0),
 652                                          last_position_(0) {}
 653
 654   byte* pos() const { return pos_; }
 655   byte* last_pc() const { return last_pc_; }
 656
 657   void Write(const RelocInfo* rinfo);
 658
 659   // Update the state of the stream after reloc info buffer
 660   // and/or code is moved while the stream is active.
 661   void Reposition(byte* pos, byte* pc) {
 662     pos_ = pos;
 663     last_pc_ = pc;
 664   }
 665
 666   // Max size (bytes) of a written RelocInfo. Longest encoding is
 667   // ExtraTag, VariableLengthPCJump, ExtraTag, pc_delta, ExtraTag, data_delta.
 668   // On ia32 and arm this is 1 + 4 + 1 + 1 + 1 + 4 = 12.
 669   // On x64 this is 1 + 4 + 1 + 1 + 1 + 8 == 16;
 670   // Here we use the maximum of the two.
 671   static const int kMaxSize = 16;
 672
 673  private:
 674   inline uint32_t WriteVariableLengthPCJump(uint32_t pc_delta);
 675   inline void WriteTaggedPC(uint32_t pc_delta, int tag);
 676   inline void WriteExtraTaggedPC(uint32_t pc_delta, int extra_tag);
 677   inline void WriteExtraTaggedIntData(int data_delta, int top_tag);
 678   inline void WriteExtraTaggedPoolData(int data, int pool_type);
 679   inline void WriteExtraTaggedData(intptr_t data_delta, int top_tag);
 680   inline void WriteTaggedData(intptr_t data_delta, int tag);
 681   inline void WriteExtraTag(int extra_tag, int top_tag);
 682
 683   byte* pos_;
 684   byte* last_pc_;
 685   int last_id_;
 686   int last_position_;
 687   DISALLOW_COPY_AND_ASSIGN(RelocInfoWriter);
 688 };
 689
 690
 691 // A RelocIterator iterates over relocation information.
 692 // Typical use:
 693 //
 694 //   for (RelocIterator it(code); !it.done(); it.next()) {
 695 //     // do something with it.rinfo() here
 696 //   }
 697 //
 698 // A mask can be specified to skip unwanted modes.
 699 class RelocIterator: public Malloced {
 700  public:
 701   // Create a new iterator positioned at
 702   // the beginning of the reloc info.
 703   // Relocation information with mode k is included in the
 704   // iteration iff bit k of mode_mask is set.
 705   explicit RelocIterator(Code* code, int mode_mask = -1);
 706   explicit RelocIterator(const CodeDesc& desc, int mode_mask = -1);
 707
 708   // Iteration
 709   bool done() const { return done_; }
 710   void next();
 711
 712   // Return pointer valid until next next().
 713   RelocInfo* rinfo() {
 714     DCHECK(!done());
 715     return &rinfo_;
 716   }
 717
 718  private:
 719   // Advance* moves the position before/after reading.
 720   // *Read* reads from current byte(s) into rinfo_.
 721   // *Get* just reads and returns info on current byte.
 722   void Advance(int bytes = 1) { pos_ -= bytes; }
 723   int AdvanceGetTag();
 724   int GetExtraTag();
 725   int GetTopTag();
 726   void ReadTaggedPC();
 727   void AdvanceReadPC();
 728   void AdvanceReadId();
 729   void AdvanceReadPoolData();
 730   void AdvanceReadPosition();
 731   void AdvanceReadData();
 732   void AdvanceReadVariableLengthPCJump();
 733   int GetLocatableTypeTag();
 734   void ReadTaggedId();
 735   void ReadTaggedPosition();
 736
 737   // If the given mode is wanted, set it in rinfo_ and return true.
 738   // Else return false. Used for efficiently skipping unwanted modes.
 739   bool SetMode(RelocInfo::Mode mode) {
 740     return (mode_mask_ & (1 << mode)) ? (rinfo_.rmode_ = mode, true) : false;
 741   }
 742
 743   byte* pos_;
 744   byte* end_;
 745   byte* code_age_sequence_;
 746   RelocInfo rinfo_;
 747   bool done_;
 748   int mode_mask_;
 749   int last_id_;
 750   int last_position_;
 751   DISALLOW_COPY_AND_ASSIGN(RelocIterator);
 752 };
 753
 754
 755 //------------------------------------------------------------------------------
 756 // External function
 757
 758 //----------------------------------------------------------------------------
 759 class IC_Utility;
 760 class SCTableReference;
 761 class Debug_Address;
 762
 763
 764 // An ExternalReference represents a C++ address used in the generated
 765 // code. All references to C++ functions and variables must be encapsulated in
 766 // an ExternalReference instance. This is done in order to track the origin of
 767 // all external references in the code so that they can be bound to the correct
 768 // addresses when deserializing a heap.
 769 class ExternalReference BASE_EMBEDDED {
 770  public:
 771   // Used in the simulator to support different native api calls.
 772   enum Type {
 773     // Builtin call.
 774     // Object* f(v8::internal::Arguments).
 775     BUILTIN_CALL,  // default
 776
 777     // Builtin that takes float arguments and returns an int.
 778     // int f(double, double).
 779     BUILTIN_COMPARE_CALL,
 780
 781     // Builtin call that returns floating point.
 782     // double f(double, double).
 783     BUILTIN_FP_FP_CALL,
 784
 785     // Builtin call that returns floating point.
 786     // double f(double).
 787     BUILTIN_FP_CALL,
 788
 789     // Builtin call that returns floating point.
 790     // double f(double, int).
 791     BUILTIN_FP_INT_CALL,
 792
 793     // Direct call to API function callback.
 794     // void f(v8::FunctionCallbackInfo&)
 795     DIRECT_API_CALL,
 796
 797     // Call to function callback via InvokeFunctionCallback.
 798     // void f(v8::FunctionCallbackInfo&, v8::FunctionCallback)
 799     PROFILING_API_CALL,
 800
 801     // Direct call to accessor getter callback.
 802     // void f(Local<Name> property, PropertyCallbackInfo& info)
 803     DIRECT_GETTER_CALL,
 804
 805     // Call to accessor getter callback via InvokeAccessorGetterCallback.
 806     // void f(Local<Name> property, PropertyCallbackInfo& info,
 807     //     AccessorNameGetterCallback callback)
 808     PROFILING_GETTER_CALL
 809   };
 810
 811   static void SetUp();
 812   static void InitializeMathExpData();
 813   static void TearDownMathExpData();
 814
 815   typedef void* ExternalReferenceRedirector(void* original, Type type);
 816
 817   ExternalReference() : address_(NULL) {}
 818
 819   ExternalReference(Builtins::CFunctionId id, Isolate* isolate);
 820
 821   ExternalReference(ApiFunction* ptr, Type type, Isolate* isolate);
 822
 823   ExternalReference(Builtins::Name name, Isolate* isolate);
 824
 825   ExternalReference(Runtime::FunctionId id, Isolate* isolate);
 826
 827   ExternalReference(const Runtime::Function* f, Isolate* isolate);
 828
 829   ExternalReference(const IC_Utility& ic_utility, Isolate* isolate);
 830
 831   explicit ExternalReference(StatsCounter* counter);
 832
 833   ExternalReference(Isolate::AddressId id, Isolate* isolate);
 834
 835   explicit ExternalReference(const SCTableReference& table_ref);
 836
 837   // Isolate as an external reference.
 838   static ExternalReference isolate_address(Isolate* isolate);
 839
 840   // One-of-a-kind references. These references are not part of a general
 841   // pattern. This means that they have to be added to the
 842   // ExternalReferenceTable in serialize.cc manually.
 843
 844   static ExternalReference incremental_marking_record_write_function(
 845       Isolate* isolate);
 846   static ExternalReference store_buffer_overflow_function(
 847       Isolate* isolate);
 848   static ExternalReference flush_icache_function(Isolate* isolate);
 849   static ExternalReference delete_handle_scope_extensions(Isolate* isolate);
 850
 851   static ExternalReference get_date_field_function(Isolate* isolate);
 852   static ExternalReference date_cache_stamp(Isolate* isolate);
 853
 854   static ExternalReference get_make_code_young_function(Isolate* isolate);
 855   static ExternalReference get_mark_code_as_executed_function(Isolate* isolate);
 856
 857   // Deoptimization support.
 858   static ExternalReference new_deoptimizer_function(Isolate* isolate);
 859   static ExternalReference compute_output_frames_function(Isolate* isolate);
 860
 861   // Log support.
 862   static ExternalReference log_enter_external_function(Isolate* isolate);
 863   static ExternalReference log_leave_external_function(Isolate* isolate);
 864
 865   // Static data in the keyed lookup cache.
 866   static ExternalReference keyed_lookup_cache_keys(Isolate* isolate);
 867   static ExternalReference keyed_lookup_cache_field_offsets(Isolate* isolate);
 868
 869   // Static variable Heap::roots_array_start()
 870   static ExternalReference roots_array_start(Isolate* isolate);
 871
 872   // Static variable Heap::allocation_sites_list_address()
 873   static ExternalReference allocation_sites_list_address(Isolate* isolate);
 874
 875   // Static variable StackGuard::address_of_jslimit()
 876   static ExternalReference address_of_stack_limit(Isolate* isolate);
 877
 878   // Static variable StackGuard::address_of_real_jslimit()
 879   static ExternalReference address_of_real_stack_limit(Isolate* isolate);
 880
 881   // Static variable RegExpStack::limit_address()
 882   static ExternalReference address_of_regexp_stack_limit(Isolate* isolate);
 883
 884   // Static variables for RegExp.
 885   static ExternalReference address_of_static_offsets_vector(Isolate* isolate);
 886   static ExternalReference address_of_regexp_stack_memory_address(
 887       Isolate* isolate);
 888   static ExternalReference address_of_regexp_stack_memory_size(
 889       Isolate* isolate);
 890
 891   // Static variable Heap::NewSpaceStart()
 892   static ExternalReference new_space_start(Isolate* isolate);
 893   static ExternalReference new_space_mask(Isolate* isolate);
 894
 895   // Write barrier.
 896   static ExternalReference store_buffer_top(Isolate* isolate);
 897
 898   // Used for fast allocation in generated code.
 899   static ExternalReference new_space_allocation_top_address(Isolate* isolate);
 900   static ExternalReference new_space_allocation_limit_address(Isolate* isolate);
 901   static ExternalReference old_pointer_space_allocation_top_address(
 902       Isolate* isolate);
 903   static ExternalReference old_pointer_space_allocation_limit_address(
 904       Isolate* isolate);
 905   static ExternalReference old_data_space_allocation_top_address(
 906       Isolate* isolate);
 907   static ExternalReference old_data_space_allocation_limit_address(
 908       Isolate* isolate);
 909
 910   static ExternalReference mod_two_doubles_operation(Isolate* isolate);
 911   static ExternalReference power_double_double_function(Isolate* isolate);
 912   static ExternalReference power_double_int_function(Isolate* isolate);
 913
 914   static ExternalReference handle_scope_next_address(Isolate* isolate);
 915   static ExternalReference handle_scope_limit_address(Isolate* isolate);
 916   static ExternalReference handle_scope_level_address(Isolate* isolate);
 917
 918   static ExternalReference scheduled_exception_address(Isolate* isolate);
 919   static ExternalReference address_of_pending_message_obj(Isolate* isolate);
 920   static ExternalReference address_of_has_pending_message(Isolate* isolate);
 921   static ExternalReference address_of_pending_message_script(Isolate* isolate);
 922
 923   // Static variables containing common double constants.
 924   static ExternalReference address_of_min_int();
 925   static ExternalReference address_of_one_half();
 926   static ExternalReference address_of_minus_one_half();
 927   static ExternalReference address_of_negative_infinity();
 928   static ExternalReference address_of_canonical_non_hole_nan();
 929   static ExternalReference address_of_the_hole_nan();
 930   static ExternalReference address_of_uint32_bias();
 931
 932   static ExternalReference math_log_double_function(Isolate* isolate);
 933
 934   static ExternalReference math_exp_constants(int constant_index);
 935   static ExternalReference math_exp_log_table();
 936
 937   static ExternalReference page_flags(Page* page);
 938
 939   static ExternalReference ForDeoptEntry(Address entry);
 940
 941   static ExternalReference cpu_features();
 942
 943   static ExternalReference debug_is_active_address(Isolate* isolate);
 944   static ExternalReference debug_after_break_target_address(Isolate* isolate);
 945   static ExternalReference debug_restarter_frame_function_pointer_address(
 946       Isolate* isolate);
 947
 948   static ExternalReference is_profiling_address(Isolate* isolate);
 949   static ExternalReference invoke_function_callback(Isolate* isolate);
 950   static ExternalReference invoke_accessor_getter_callback(Isolate* isolate);
 951
 952   Address address() const { return reinterpret_cast<Address>(address_); }
 953
 954   // Function Debug::Break()
 955   static ExternalReference debug_break(Isolate* isolate);
 956
 957   // Used to check if single stepping is enabled in generated code.
 958   static ExternalReference debug_step_in_fp_address(Isolate* isolate);
 959
 960 #ifndef V8_INTERPRETED_REGEXP
 961   // C functions called from RegExp generated code.
 962
 963   // Function NativeRegExpMacroAssembler::CaseInsensitiveCompareUC16()
 964   static ExternalReference re_case_insensitive_compare_uc16(Isolate* isolate);
 965
 966   // Function RegExpMacroAssembler*::CheckStackGuardState()
 967   static ExternalReference re_check_stack_guard_state(Isolate* isolate);
 968
 969   // Function NativeRegExpMacroAssembler::GrowStack()
 970   static ExternalReference re_grow_stack(Isolate* isolate);
 971
 972   // byte NativeRegExpMacroAssembler::word_character_bitmap
 973   static ExternalReference re_word_character_map();
 974
 975 #endif
 976
 977   // This lets you register a function that rewrites all external references.
 978   // Used by the ARM simulator to catch calls to external references.
 979   static void set_redirector(Isolate* isolate,
 980                              ExternalReferenceRedirector* redirector) {
 981     // We can't stack them.
 982     DCHECK(isolate->external_reference_redirector() == NULL);
 983     isolate->set_external_reference_redirector(
 984         reinterpret_cast<ExternalReferenceRedirectorPointer*>(redirector));
 985   }
 986
 987   static ExternalReference stress_deopt_count(Isolate* isolate);
 988
 989  private:
 990   explicit ExternalReference(void* address)
 991       : address_(address) {}
 992
 993   static void* Redirect(Isolate* isolate,
 994                         Address address_arg,
 995                         Type type = ExternalReference::BUILTIN_CALL) {
 996     ExternalReferenceRedirector* redirector =
 997         reinterpret_cast<ExternalReferenceRedirector*>(
 998             isolate->external_reference_redirector());
 999     void* address = reinterpret_cast<void*>(address_arg);
1000     void* answer = (redirector == NULL) ?
1001                    address :
1002                    (*redirector)(address, type);
1003     return answer;
1004   }
1005
1006   void* address_;
1007 };
1008
1009 bool operator==(ExternalReference, ExternalReference);
1010 bool operator!=(ExternalReference, ExternalReference);
1011
1012 size_t hash_value(ExternalReference);
1013
1014 std::ostream& operator<<(std::ostream&, ExternalReference);
1015
1016
1017 // -----------------------------------------------------------------------------
1018 // Position recording support
1019
1020 struct PositionState {
1021   PositionState() : current_position(RelocInfo::kNoPosition),
1022                     written_position(RelocInfo::kNoPosition),
1023                     current_statement_position(RelocInfo::kNoPosition),
1024                     written_statement_position(RelocInfo::kNoPosition) {}
1025
1026   int current_position;
1027   int written_position;
1028
1029   int current_statement_position;
1030   int written_statement_position;
1031 };
1032
1033
1034 class PositionsRecorder BASE_EMBEDDED {
1035  public:
1036   explicit PositionsRecorder(Assembler* assembler)
1037       : assembler_(assembler) {
1038     jit_handler_data_ = NULL;
1039   }
1040
1041   void AttachJITHandlerData(void* user_data) {
1042     jit_handler_data_ = user_data;
1043   }
1044
1045   void* DetachJITHandlerData() {
1046     void* old_data = jit_handler_data_;
1047     jit_handler_data_ = NULL;
1048     return old_data;
1049   }
1050   // Set current position to pos.
1051   void RecordPosition(int pos);
1052
1053   // Set current statement position to pos.
1054   void RecordStatementPosition(int pos);
1055
1056   // Write recorded positions to relocation information.
1057   bool WriteRecordedPositions();
1058
1059   int current_position() const { return state_.current_position; }
1060
1061   int current_statement_position() const {
1062     return state_.current_statement_position;
1063   }
1064
1065  private:
1066   Assembler* assembler_;
1067   PositionState state_;
1068
1069   // Currently jit_handler_data_ is used to store JITHandler-specific data
1070   // over the lifetime of a PositionsRecorder
1071   void* jit_handler_data_;
1072   friend class PreservePositionScope;
1073
1074   DISALLOW_COPY_AND_ASSIGN(PositionsRecorder);
1075 };
1076
1077
1078 class PreservePositionScope BASE_EMBEDDED {
1079  public:
1080   explicit PreservePositionScope(PositionsRecorder* positions_recorder)
1081       : positions_recorder_(positions_recorder),
1082         saved_state_(positions_recorder->state_) {}
1083
1084   ~PreservePositionScope() {
1085     positions_recorder_->state_ = saved_state_;
1086   }
1087
1088  private:
1089   PositionsRecorder* positions_recorder_;
1090   const PositionState saved_state_;
1091
1092   DISALLOW_COPY_AND_ASSIGN(PreservePositionScope);
1093 };
1094
1095
1096 // -----------------------------------------------------------------------------
1097 // Utility functions
1098
1099 inline int NumberOfBitsSet(uint32_t x) {
1100   unsigned int num_bits_set;
1101   for (num_bits_set = 0; x; x >>= 1) {
1102     num_bits_set += x & 1;
1103   }
1104   return num_bits_set;
1105 }
1106
1107 bool EvalComparison(Token::Value op, double op1, double op2);
1108
1109 // Computes pow(x, y) with the special cases in the spec for Math.pow.
1110 double power_helper(double x, double y);
1111 double power_double_int(double x, int y);
1112 double power_double_double(double x, double y);
1113
1114 // Helper class for generating code or data associated with the code
1115 // right after a call instruction. As an example this can be used to
1116 // generate safepoint data after calls for crankshaft.
1117 class CallWrapper {
1118  public:
1119   CallWrapper() { }
1120   virtual ~CallWrapper() { }
1121   // Called just before emitting a call. Argument is the size of the generated
1122   // call code.
1123   virtual void BeforeCall(int call_size) const = 0;
1124   // Called just after emitting a call, i.e., at the return site for the call.
1125   virtual void AfterCall() const = 0;
1126 };
1127
1128 class NullCallWrapper : public CallWrapper {
1129  public:
1130   NullCallWrapper() { }
1131   virtual ~NullCallWrapper() { }
1132   virtual void BeforeCall(int call_size) const { }
1133   virtual void AfterCall() const { }
1134 };
1135
1136
1137 } }  // namespace v8::internal
1138
1139 #endif  // V8_ASSEMBLER_H_