v8  3.14.5(node0.10.28)
V8 is Google's open source JavaScript engine
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
safepoint-table.h
Go to the documentation of this file.
1 // Copyright 2011 the V8 project authors. All rights reserved.
2 // Redistribution and use in source and binary forms, with or without
3 // modification, are permitted provided that the following conditions are
4 // met:
5 //
6 // * Redistributions of source code must retain the above copyright
7 // notice, this list of conditions and the following disclaimer.
8 // * Redistributions in binary form must reproduce the above
9 // copyright notice, this list of conditions and the following
10 // disclaimer in the documentation and/or other materials provided
11 // with the distribution.
12 // * Neither the name of Google Inc. nor the names of its
13 // contributors may be used to endorse or promote products derived
14 // from this software without specific prior written permission.
15 //
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 
28 #ifndef V8_SAFEPOINT_TABLE_H_
29 #define V8_SAFEPOINT_TABLE_H_
30 
31 #include "allocation.h"
32 #include "heap.h"
33 #include "v8memory.h"
34 #include "zone.h"
35 
36 namespace v8 {
37 namespace internal {
38 
39 struct Register;
40 
41 class SafepointEntry BASE_EMBEDDED {
42  public:
43  SafepointEntry() : info_(0), bits_(NULL) {}
44 
45  SafepointEntry(unsigned info, uint8_t* bits) : info_(info), bits_(bits) {
46  ASSERT(is_valid());
47  }
48 
49  bool is_valid() const { return bits_ != NULL; }
50 
51  bool Equals(const SafepointEntry& other) const {
52  return info_ == other.info_ && bits_ == other.bits_;
53  }
54 
55  void Reset() {
56  info_ = 0;
57  bits_ = NULL;
58  }
59 
60  int deoptimization_index() const {
61  ASSERT(is_valid());
62  return DeoptimizationIndexField::decode(info_);
63  }
64 
65  static const int kArgumentsFieldBits = 3;
66  static const int kSaveDoublesFieldBits = 1;
67  static const int kDeoptIndexBits =
68  32 - kArgumentsFieldBits - kSaveDoublesFieldBits;
70  public BitField<int, 0, kDeoptIndexBits> {}; // NOLINT
72  public BitField<unsigned,
73  kDeoptIndexBits,
74  kArgumentsFieldBits> {}; // NOLINT
76  public BitField<bool,
77  kDeoptIndexBits + kArgumentsFieldBits,
78  kSaveDoublesFieldBits> { }; // NOLINT
79 
80  int argument_count() const {
81  ASSERT(is_valid());
82  return ArgumentsField::decode(info_);
83  }
84 
85  bool has_doubles() const {
86  ASSERT(is_valid());
87  return SaveDoublesField::decode(info_);
88  }
89 
90  uint8_t* bits() {
91  ASSERT(is_valid());
92  return bits_;
93  }
94 
95  bool HasRegisters() const;
96  bool HasRegisterAt(int reg_index) const;
97 
98  private:
99  unsigned info_;
100  uint8_t* bits_;
101 };
102 
103 
104 class SafepointTable BASE_EMBEDDED {
105  public:
106  explicit SafepointTable(Code* code);
107 
108  int size() const {
109  return kHeaderSize +
110  (length_ * (kPcAndDeoptimizationIndexSize + entry_size_)); }
111  unsigned length() const { return length_; }
112  unsigned entry_size() const { return entry_size_; }
113 
114  unsigned GetPcOffset(unsigned index) const {
115  ASSERT(index < length_);
116  return Memory::uint32_at(GetPcOffsetLocation(index));
117  }
118 
119  SafepointEntry GetEntry(unsigned index) const {
120  ASSERT(index < length_);
121  unsigned info = Memory::uint32_at(GetInfoLocation(index));
122  uint8_t* bits = &Memory::uint8_at(entries_ + (index * entry_size_));
123  return SafepointEntry(info, bits);
124  }
125 
126  // Returns the entry for the given pc.
127  SafepointEntry FindEntry(Address pc) const;
128 
129  void PrintEntry(unsigned index) const;
130 
131  private:
132  static const uint8_t kNoRegisters = 0xFF;
133 
134  static const int kLengthOffset = 0;
135  static const int kEntrySizeOffset = kLengthOffset + kIntSize;
136  static const int kHeaderSize = kEntrySizeOffset + kIntSize;
137 
138  static const int kPcSize = kIntSize;
139  static const int kDeoptimizationIndexSize = kIntSize;
140  static const int kPcAndDeoptimizationIndexSize =
141  kPcSize + kDeoptimizationIndexSize;
142 
143  Address GetPcOffsetLocation(unsigned index) const {
144  return pc_and_deoptimization_indexes_ +
145  (index * kPcAndDeoptimizationIndexSize);
146  }
147 
148  Address GetInfoLocation(unsigned index) const {
149  return GetPcOffsetLocation(index) + kPcSize;
150  }
151 
152  static void PrintBits(uint8_t byte, int digits);
153 
154  AssertNoAllocation no_allocation_;
155  Code* code_;
156  unsigned length_;
157  unsigned entry_size_;
158 
159  Address pc_and_deoptimization_indexes_;
160  Address entries_;
161 
162  friend class SafepointTableBuilder;
163  friend class SafepointEntry;
164 
165  DISALLOW_COPY_AND_ASSIGN(SafepointTable);
166 };
167 
168 
169 class Safepoint BASE_EMBEDDED {
170  public:
171  typedef enum {
172  kSimple = 0,
173  kWithRegisters = 1 << 0,
174  kWithDoubles = 1 << 1,
175  kWithRegistersAndDoubles = kWithRegisters | kWithDoubles
176  } Kind;
177 
178  enum DeoptMode {
180  kLazyDeopt
181  };
182 
183  static const int kNoDeoptimizationIndex =
184  (1 << (SafepointEntry::kDeoptIndexBits)) - 1;
185 
186  void DefinePointerSlot(int index, Zone* zone) { indexes_->Add(index, zone); }
187  void DefinePointerRegister(Register reg, Zone* zone);
188 
189  private:
190  Safepoint(ZoneList<int>* indexes, ZoneList<int>* registers) :
191  indexes_(indexes), registers_(registers) { }
192  ZoneList<int>* indexes_;
193  ZoneList<int>* registers_;
194 
195  friend class SafepointTableBuilder;
196 };
197 
198 
199 class SafepointTableBuilder BASE_EMBEDDED {
200  public:
201  explicit SafepointTableBuilder(Zone* zone)
202  : deoptimization_info_(32, zone),
203  deopt_index_list_(32, zone),
204  indexes_(32, zone),
205  registers_(32, zone),
206  emitted_(false),
207  last_lazy_safepoint_(0),
208  zone_(zone) { }
209 
210  // Get the offset of the emitted safepoint table in the code.
211  unsigned GetCodeOffset() const;
212 
213  // Define a new safepoint for the current position in the body.
214  Safepoint DefineSafepoint(Assembler* assembler,
215  Safepoint::Kind kind,
216  int arguments,
217  Safepoint::DeoptMode mode);
218 
219  // Record deoptimization index for lazy deoptimization for the last
220  // outstanding safepoints.
221  void RecordLazyDeoptimizationIndex(int index);
222 
223  // Emit the safepoint table after the body. The number of bits per
224  // entry must be enough to hold all the pointer indexes.
225  void Emit(Assembler* assembler, int bits_per_entry);
226 
227 
228  private:
229  struct DeoptimizationInfo {
230  unsigned pc;
231  unsigned arguments;
232  bool has_doubles;
233  };
234 
235  uint32_t EncodeExceptPC(const DeoptimizationInfo& info, unsigned index);
236 
237  ZoneList<DeoptimizationInfo> deoptimization_info_;
238  ZoneList<unsigned> deopt_index_list_;
239  ZoneList<ZoneList<int>*> indexes_;
240  ZoneList<ZoneList<int>*> registers_;
241 
242  unsigned offset_;
243  bool emitted_;
244  int last_lazy_safepoint_;
245 
246  Zone* zone_;
247 
248  DISALLOW_COPY_AND_ASSIGN(SafepointTableBuilder);
249 };
250 
251 } } // namespace v8::internal
252 
253 #endif // V8_SAFEPOINT_TABLE_H_
byte * Address
Definition: globals.h:157
unsigned GetPcOffset(unsigned index) const
#define ASSERT(condition)
Definition: checks.h:270
SafepointEntry GetEntry(unsigned index) const
const int kIntSize
Definition: globals.h:217
static uint8_t & uint8_at(Address addr)
Definition: v8memory.h:39
uint8_t byte
Definition: globals.h:156
unsigned entry_size() const
#define DISALLOW_COPY_AND_ASSIGN(TypeName)
Definition: globals.h:307
const Register pc
SafepointEntry(unsigned info, uint8_t *bits)
#define BASE_EMBEDDED
Definition: allocation.h:68
activate correct semantics for inheriting readonliness false
Definition: flags.cc:141
void DefinePointerSlot(int index, Zone *zone)
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 and VFP2 enable use of VFP2 instructions if available enable use of SDIV and UDIV instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of MIPS FPU instructions if NULL
Definition: flags.cc:301
static uint32_t & uint32_at(Address addr)
Definition: v8memory.h:47
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination use dead code elimination trace on stack replacement optimize closures cache optimized code for closures functions with arguments object loop weight for representation inference allow uint32 values on optimize frames if they are used only in safe operations track parallel recompilation enable all profiler experiments number of stack frames inspected by the profiler call recompile stub directly when self optimizing trigger profiler ticks based on counting instead of timing weight back edges by jump distance for interrupt triggering percentage of ICs that must have type info to allow optimization watch_ic_patching retry_self_opt interrupt_at_exit extra verbose compilation tracing generate extra code(assertions) for debugging") DEFINE_bool(code_comments
bool Equals(const SafepointEntry &other) const