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