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
preparser-api.cc
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 #ifdef _MSC_VER
29 #define V8_WIN32_LEAN_AND_MEAN
30 #include "win32-headers.h"
31 #endif
32 
33 #include "../include/v8-preparser.h"
34 
35 #include "globals.h"
36 #include "checks.h"
37 #include "allocation.h"
38 #include "utils.h"
39 #include "list.h"
40 #include "hashmap.h"
41 #include "preparse-data-format.h"
42 #include "preparse-data.h"
43 #include "preparser.h"
44 
45 namespace v8 {
46 namespace internal {
47 
48 // UTF16Buffer based on a v8::UnicodeInputStream.
50  public:
51  /* The InputStreamUtf16Buffer maintains an internal buffer
52  * that is filled in chunks from the Utf16CharacterStream.
53  * It also maintains unlimited pushback capability, but optimized
54  * for small pushbacks.
55  * The pushback_buffer_ pointer points to the limit of pushbacks
56  * in the current buffer. There is room for a few pushback'ed chars before
57  * the buffer containing the most recently read chunk. If this is overflowed,
58  * an external buffer is allocated/reused to hold further pushbacks, and
59  * pushback_buffer_ and buffer_cursor_/buffer_end_ now points to the
60  * new buffer. When this buffer is read to the end again, the cursor is
61  * switched back to the internal buffer
62  */
65  stream_(stream),
66  pushback_buffer_(buffer_),
67  pushback_buffer_end_cache_(NULL),
68  pushback_buffer_backing_(NULL),
69  pushback_buffer_backing_size_(0) {
70  buffer_cursor_ = buffer_end_ = buffer_ + kPushBackSize;
71  }
72 
74  if (pushback_buffer_backing_ != NULL) {
75  DeleteArray(pushback_buffer_backing_);
76  }
77  }
78 
79  virtual void PushBack(uc32 ch) {
80  ASSERT(pos_ > 0);
81  if (ch == kEndOfInput) {
82  pos_--;
83  return;
84  }
85  if (buffer_cursor_ <= pushback_buffer_) {
86  // No more room in the current buffer to do pushbacks.
87  if (pushback_buffer_end_cache_ == NULL) {
88  // We have overflowed the pushback space at the beginning of buffer_.
89  // Switch to using a separate allocated pushback buffer.
90  if (pushback_buffer_backing_ == NULL) {
91  // Allocate a buffer the first time we need it.
92  pushback_buffer_backing_ = NewArray<uc16>(kPushBackSize);
93  pushback_buffer_backing_size_ = kPushBackSize;
94  }
95  pushback_buffer_ = pushback_buffer_backing_;
96  pushback_buffer_end_cache_ = buffer_end_;
97  buffer_end_ = pushback_buffer_backing_ + pushback_buffer_backing_size_;
99  } else {
100  // Hit the bottom of the allocated pushback buffer.
101  // Double the buffer and continue.
102  uc16* new_buffer = NewArray<uc16>(pushback_buffer_backing_size_ * 2);
103  memcpy(new_buffer + pushback_buffer_backing_size_,
104  pushback_buffer_backing_,
105  pushback_buffer_backing_size_);
106  DeleteArray(pushback_buffer_backing_);
107  buffer_cursor_ = new_buffer + pushback_buffer_backing_size_;
108  pushback_buffer_backing_ = pushback_buffer_ = new_buffer;
109  buffer_end_ = pushback_buffer_backing_ + pushback_buffer_backing_size_;
110  }
111  }
112  pushback_buffer_[buffer_cursor_ - pushback_buffer_- 1] =
113  static_cast<uc16>(ch);
114  pos_--;
115  }
116 
117  protected:
118  virtual bool ReadBlock() {
119  if (pushback_buffer_end_cache_ != NULL) {
120  buffer_cursor_ = buffer_;
121  buffer_end_ = pushback_buffer_end_cache_;
122  pushback_buffer_end_cache_ = NULL;
123  return buffer_end_ > buffer_cursor_;
124  }
125  // Copy the top of the buffer into the pushback area.
126  int32_t value;
127  uc16* buffer_start = buffer_ + kPushBackSize;
128  buffer_cursor_ = buffer_end_ = buffer_start;
129  while ((value = stream_->Next()) >= 0) {
130  if (value >
131  static_cast<int32_t>(unibrow::Utf16::kMaxNonSurrogateCharCode)) {
132  buffer_start[buffer_end_++ - buffer_start] =
134  buffer_start[buffer_end_++ - buffer_start] =
136  } else {
137  // buffer_end_ is a const pointer, but buffer_ is writable.
138  buffer_start[buffer_end_++ - buffer_start] = static_cast<uc16>(value);
139  }
140  // Stop one before the end of the buffer in case we get a surrogate pair.
141  if (buffer_end_ <= buffer_ + 1 + kPushBackSize + kBufferSize) break;
142  }
143  return buffer_end_ > buffer_start;
144  }
145 
146  virtual unsigned SlowSeekForward(unsigned pos) {
147  // Seeking in the input is not used by preparsing.
148  // It's only used by the real parser based on preparser data.
149  UNIMPLEMENTED();
150  return 0;
151  }
152 
153  private:
154  static const unsigned kBufferSize = 512;
155  static const unsigned kPushBackSize = 16;
156  v8::UnicodeInputStream* const stream_;
157  // Buffer holding first kPushBackSize characters of pushback buffer,
158  // then kBufferSize chars of read-ahead.
159  // The pushback buffer is only used if pushing back characters past
160  // the start of a block.
161  uc16 buffer_[kPushBackSize + kBufferSize];
162  // Limit of pushbacks before new allocation is necessary.
163  uc16* pushback_buffer_;
164  // Only if that pushback buffer at the start of buffer_ isn't sufficient
165  // is the following used.
166  const uc16* pushback_buffer_end_cache_;
167  uc16* pushback_buffer_backing_;
168  unsigned pushback_buffer_backing_size_;
169 };
170 
171 
172 // Functions declared by allocation.h and implemented in both api.cc (for v8)
173 // or here (for a stand-alone preparser).
174 
175 void FatalProcessOutOfMemory(const char* reason) {
176  V8_Fatal(__FILE__, __LINE__, reason);
177 }
178 
179 bool EnableSlowAsserts() { return true; }
180 
181 } // namespace internal.
182 
183 
185 
186 
187 PreParserData Preparse(UnicodeInputStream* input, size_t max_stack) {
188  internal::InputStreamUtf16Buffer buffer(input);
189  uintptr_t stack_limit = reinterpret_cast<uintptr_t>(&buffer) - max_stack;
190  internal::UnicodeCache unicode_cache;
191  internal::Scanner scanner(&unicode_cache);
192  scanner.Initialize(&buffer);
196  &recorder,
198  stack_limit);
201  }
202  internal::Vector<unsigned> pre_data = recorder.ExtractData();
203  size_t size = pre_data.length() * sizeof(pre_data[0]);
204  unsigned char* data = reinterpret_cast<unsigned char*>(pre_data.start());
205  return PreParserData(size, data);
206 }
207 
208 } // namespace v8.
209 
210 
211 // Used by ASSERT macros and other immediate exits.
212 extern "C" void V8_Fatal(const char* file, int line, const char* format, ...) {
213  exit(EXIT_FAILURE);
214 }
static uchar TrailSurrogate(int char_code)
Definition: unicode.h:146
static uchar LeadSurrogate(int char_code)
Definition: unicode.h:143
static const uc32 kEndOfInput
Definition: scanner.h:128
int32_t uc32
Definition: globals.h:260
int int32_t
Definition: unicode.cc:47
InputStreamUtf16Buffer(v8::UnicodeInputStream *stream)
#define ASSERT(condition)
Definition: checks.h:270
virtual int32_t Next()=0
T * start() const
Definition: utils.h:390
static const uchar kMaxNonSurrogateCharCode
Definition: unicode.h:133
int length() const
Definition: utils.h:384
PreParserData V8EXPORT Preparse(UnicodeInputStream *input, size_t max_stack_size)
void Initialize(Utf16CharacterStream *source)
Definition: scanner.cc:48
virtual Vector< unsigned > ExtractData()
bool EnableSlowAsserts()
Definition: checks.cc:105
void V8_Fatal(const char *file, int line, const char *format,...)
void FatalProcessOutOfMemory(const char *message)
#define UNIMPLEMENTED()
Definition: checks.h:48
uint16_t uc16
Definition: globals.h:259
static PreParseResult PreParseProgram(i::Scanner *scanner, i::ParserRecorder *log, int flags, uintptr_t stack_limit)
Definition: preparser.h:140
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 PreParserData StackOverflow()
Definition: v8-preparser.h:78
void DeleteArray(T *array)
Definition: allocation.h:91
virtual unsigned SlowSeekForward(unsigned pos)