therubyracer 0.7.4 → 0.7.5

data/ext/v8/upstream/{2.1.10 → 2.3.3}/src/parser.cc

@@ -33,12 +33,16 @@
 #include "codegen.h"
 #include "compiler.h"
 #include "messages.h"
+#include "parser.h"
 #include "platform.h"
 #include "runtime.h"
-#include "parser.h"
+#include "scopeinfo.h"
 #include "scopes.h"
 #include "string-stream.h"
 
+#include "ast-inl.h"
+#include "jump-target-inl.h"
+
 namespace v8 {
 namespace internal {
 
@@ -131,6 +135,7 @@ class Parser {
 
   // Report syntax error
   void ReportUnexpectedToken(Token::Value token);
+  void ReportInvalidPreparseData(Handle<String> name, bool* ok);
 
   Handle<Script> script_;
   Scanner scanner_;
@@ -1965,7 +1970,8 @@ Statement* Parser::ParseNativeDeclaration(bool* ok) {
   Handle<Code> code = Handle<Code>(fun->shared()->code());
   Handle<Code> construct_stub = Handle<Code>(fun->shared()->construct_stub());
   Handle<SharedFunctionInfo> shared =
-      Factory::NewSharedFunctionInfo(name, literals, code);
+      Factory::NewSharedFunctionInfo(name, literals, code,
+          Handle<SerializedScopeInfo>(fun->shared()->scope_info()));
   shared->set_construct_stub(*construct_stub);
 
   // Copy the function data to the shared function info.
@@ -2864,10 +2870,13 @@ Expression* Parser::ParseConditionalExpression(bool accept_IN, bool* ok) {
   // In parsing the first assignment expression in conditional
   // expressions we always accept the 'in' keyword; see ECMA-262,
   // section 11.12, page 58.
+  int left_position = scanner().peek_location().beg_pos;
   Expression* left = ParseAssignmentExpression(true, CHECK_OK);
   Expect(Token::COLON, CHECK_OK);
+  int right_position = scanner().peek_location().beg_pos;
   Expression* right = ParseAssignmentExpression(accept_IN, CHECK_OK);
-  return NEW(Conditional(expression, left, right));
+  return NEW(Conditional(expression, left, right,
+                         left_position, right_position));
 }
 
 
@@ -3257,6 +3266,15 @@ void Parser::ReportUnexpectedToken(Token::Value token) {
 }
 
 
+void Parser::ReportInvalidPreparseData(Handle<String> name, bool* ok) {
+  SmartPointer<char> name_string = name->ToCString(DISALLOW_NULLS);
+  const char* element[1] = { *name_string };
+  ReportMessage("invalid_preparser_data",
+                Vector<const char*>(element, 1));
+  *ok = false;
+}
+
+
 Expression* Parser::ParsePrimaryExpression(bool* ok) {
   // PrimaryExpression ::
   //   'this'
@@ -3804,7 +3822,14 @@ FunctionLiteral* Parser::ParseFunctionLiteral(Handle<String> var_name,
     Handle<FixedArray> this_property_assignments;
     if (is_lazily_compiled && pre_data() != NULL) {
       FunctionEntry entry = pre_data()->GetFunctionEnd(start_pos);
+      if (!entry.is_valid()) {
+        ReportInvalidPreparseData(name, CHECK_OK);
+      }
       int end_pos = entry.end_pos();
+      if (end_pos <= start_pos) {
+        // End position greater than end of stream is safe, and hard to check.
+        ReportInvalidPreparseData(name, CHECK_OK);
+      }
       Counters::total_preparse_skipped.Increment(end_pos - start_pos);
       scanner_.SeekForward(end_pos);
       materialized_literal_count = entry.literal_count();
@@ -5070,12 +5095,12 @@ ScriptDataImpl::~ScriptDataImpl() {
 
 
 int ScriptDataImpl::Length() {
-  return store_.length();
+  return store_.length() * sizeof(unsigned);
 }
 
 
-unsigned* ScriptDataImpl::Data() {
-  return store_.start();
+const char* ScriptDataImpl::Data() {
+  return reinterpret_cast<const char*>(store_.start());
 }
 
 

data/ext/v8/upstream/{2.1.10 → 2.3.3}/src/parser.h

@@ -90,7 +90,7 @@ class ScriptDataImpl : public ScriptData {
         last_entry_(0) { }
   virtual ~ScriptDataImpl();
   virtual int Length();
-  virtual unsigned* Data();
+  virtual const char* Data();
   virtual bool HasError();
   FunctionEntry GetFunctionEnd(int start);
   bool SanityCheck();

data/ext/v8/upstream/{2.1.10 → 2.3.3}/src/platform-freebsd.cc

@@ -84,6 +84,12 @@ void OS::Setup() {
 }
 
 
+void OS::ReleaseStore(volatile AtomicWord* ptr, AtomicWord value) {
+  __asm__ __volatile__("" : : : "memory");
+  *ptr = value;
+}
+
+
 uint64_t OS::CpuFeaturesImpliedByPlatform() {
   return 0;  // FreeBSD runs on anything.
 }
@@ -286,14 +292,12 @@ void OS::LogSharedLibraryAddresses() {
 
 int OS::StackWalk(Vector<OS::StackFrame> frames) {
   int frames_size = frames.length();
-  void** addresses = NewArray<void*>(frames_size);
+  ScopedVector<void*> addresses(frames_size);
 
-  int frames_count = backtrace(addresses, frames_size);
+  int frames_count = backtrace(addresses.start(), frames_size);
 
-  char** symbols;
-  symbols = backtrace_symbols(addresses, frames_count);
+  char** symbols = backtrace_symbols(addresses.start(), frames_count);
   if (symbols == NULL) {
-    DeleteArray(addresses);
     return kStackWalkError;
   }
 
@@ -308,7 +312,6 @@ int OS::StackWalk(Vector<OS::StackFrame> frames) {
     frames[i].text[kStackWalkMaxTextLen - 1] = '\0';
   }
 
-  DeleteArray(addresses);
   free(symbols);
 
   return frames_count;

data/ext/v8/upstream/{2.1.10 → 2.3.3}/src/platform-linux.cc

@@ -165,6 +165,29 @@ int OS::ActivationFrameAlignment() {
 }
 
 
+#ifdef V8_TARGET_ARCH_ARM
+// 0xffff0fa0 is the hard coded address of a function provided by
+// the kernel which implements a memory barrier. On older
+// ARM architecture revisions (pre-v6) this may be implemented using
+// a syscall. This address is stable, and in active use (hard coded)
+// by at least glibc-2.7 and the Android C library.
+typedef void (*LinuxKernelMemoryBarrierFunc)(void);
+LinuxKernelMemoryBarrierFunc pLinuxKernelMemoryBarrier __attribute__((weak)) =
+    (LinuxKernelMemoryBarrierFunc) 0xffff0fa0;
+#endif
+
+void OS::ReleaseStore(volatile AtomicWord* ptr, AtomicWord value) {
+#if defined(V8_TARGET_ARCH_ARM) && defined(__arm__)
+  // Only use on ARM hardware.
+  pLinuxKernelMemoryBarrier();
+#else
+  __asm__ __volatile__("" : : : "memory");
+  // An x86 store acts as a release barrier.
+#endif
+  *ptr = value;
+}
+
+
 const char* OS::LocalTimezone(double time) {
   if (isnan(time)) return "";
   time_t tv = static_cast<time_t>(floor(time/msPerSecond));
@@ -376,14 +399,12 @@ int OS::StackWalk(Vector<OS::StackFrame> frames) {
   // backtrace is a glibc extension.
 #ifdef __GLIBC__
   int frames_size = frames.length();
-  void** addresses = NewArray<void*>(frames_size);
+  ScopedVector<void*> addresses(frames_size);
 
-  int frames_count = backtrace(addresses, frames_size);
+  int frames_count = backtrace(addresses.start(), frames_size);
 
-  char** symbols;
-  symbols = backtrace_symbols(addresses, frames_count);
+  char** symbols = backtrace_symbols(addresses.start(), frames_count);
   if (symbols == NULL) {
-    DeleteArray(addresses);
     return kStackWalkError;
   }
 
@@ -398,7 +419,6 @@ int OS::StackWalk(Vector<OS::StackFrame> frames) {
     frames[i].text[kStackWalkMaxTextLen - 1] = '\0';
   }
 
-  DeleteArray(addresses);
   free(symbols);
 
   return frames_count;

data/ext/v8/upstream/{2.1.10 → 2.3.3}/src/platform-macos.cc

@@ -39,6 +39,7 @@
 #include <pthread.h>
 #include <semaphore.h>
 #include <signal.h>
+#include <libkern/OSAtomic.h>
 #include <mach/mach.h>
 #include <mach/semaphore.h>
 #include <mach/task.h>
@@ -259,6 +260,12 @@ int OS::ActivationFrameAlignment() {
 }
 
 
+void OS::ReleaseStore(volatile AtomicWord* ptr, AtomicWord value) {
+  OSMemoryBarrier();
+  *ptr = value;
+}
+
+
 const char* OS::LocalTimezone(double time) {
   if (isnan(time)) return "";
   time_t tv = static_cast<time_t>(floor(time/msPerSecond));
@@ -283,13 +290,12 @@ int OS::StackWalk(Vector<StackFrame> frames) {
     return 0;
 
   int frames_size = frames.length();
-  void** addresses = NewArray<void*>(frames_size);
-  int frames_count = backtrace(addresses, frames_size);
+  ScopedVector<void*> addresses(frames_size);
+
+  int frames_count = backtrace(addresses.start(), frames_size);
 
-  char** symbols;
-  symbols = backtrace_symbols(addresses, frames_count);
+  char** symbols = backtrace_symbols(addresses.start(), frames_count);
   if (symbols == NULL) {
-    DeleteArray(addresses);
     return kStackWalkError;
   }
 
@@ -305,7 +311,6 @@ int OS::StackWalk(Vector<StackFrame> frames) {
     frames[i].text[kStackWalkMaxTextLen - 1] = '\0';
   }
 
-  DeleteArray(addresses);
   free(symbols);
 
   return frames_count;

data/ext/v8/upstream/{2.1.10 → 2.3.3}/src/platform-openbsd.cc

@@ -83,6 +83,12 @@ void OS::Setup() {
 }
 
 
+void OS::ReleaseStore(volatile AtomicWord* ptr, AtomicWord value) {
+  __asm__ __volatile__("" : : : "memory");
+  *ptr = value;
+}
+
+
 uint64_t OS::CpuFeaturesImpliedByPlatform() {
   return 0;  // OpenBSD runs on anything.
 }

data/ext/v8/upstream/{2.1.10 → 2.3.3}/src/platform-solaris.cc

@@ -35,7 +35,8 @@
 #include <sys/stack.h>  // for stack alignment
 #include <unistd.h>  // getpagesize(), usleep()
 #include <sys/mman.h>  // mmap()
-#include <execinfo.h>  // backtrace(), backtrace_symbols()
+#include <ucontext.h>  // walkstack(), getcontext()
+#include <dlfcn.h>     // dladdr
 #include <pthread.h>
 #include <sched.h>  // for sched_yield
 #include <semaphore.h>
@@ -53,6 +54,24 @@
 #include "platform.h"
 
 
+// It seems there is a bug in some Solaris distributions (experienced in
+// SunOS 5.10 Generic_141445-09) which make it difficult or impossible to
+// access signbit() despite the availability of other C99 math functions.
+#ifndef signbit
+// Test sign - usually defined in math.h
+int signbit(double x) {
+  // We need to take care of the special case of both positive and negative
+  // versions of zero.
+  if (x == 0) {
+    return fpclass(x) & FP_NZERO;
+  } else {
+    // This won't detect negative NaN but that should be okay since we don't
+    // assume that behavior.
+    return x < 0;
+  }
+}
+#endif  // signbit
+
 namespace v8 {
 namespace internal {
 
@@ -88,6 +107,12 @@ int OS::ActivationFrameAlignment() {
 }
 
 
+void OS::ReleaseStore(volatile AtomicWord* ptr, AtomicWord value) {
+  __asm__ __volatile__("" : : : "memory");
+  *ptr = value;
+}
+
+
 const char* OS::LocalTimezone(double time) {
   if (isnan(time)) return "";
   time_t tv = static_cast<time_t>(floor(time/msPerSecond));
@@ -231,34 +256,55 @@ void OS::LogSharedLibraryAddresses() {
 }
 
 
-int OS::StackWalk(Vector<OS::StackFrame> frames) {
-  int frames_size = frames.length();
-  void** addresses = NewArray<void*>(frames_size);
+struct StackWalker {
+  Vector<OS::StackFrame>& frames;
+  int index;
+};
 
-  int frames_count = backtrace(addresses, frames_size);
 
-  char** symbols;
-  symbols = backtrace_symbols(addresses, frames_count);
-  if (symbols == NULL) {
-    DeleteArray(addresses);
-    return kStackWalkError;
-  }
+static int StackWalkCallback(uintptr_t pc, int signo, void* data) {
+  struct StackWalker* walker = static_cast<struct StackWalker*>(data);
+  Dl_info info;
+
+  int i = walker->index;
 
-  for (int i = 0; i < frames_count; i++) {
-    frames[i].address = addresses[i];
-    // Format a text representation of the frame based on the information
-    // available.
-    SNPrintF(MutableCStrVector(frames[i].text, kStackWalkMaxTextLen),
-             "%s",
-             symbols[i]);
-    // Make sure line termination is in place.
-    frames[i].text[kStackWalkMaxTextLen - 1] = '\0';
+  walker->frames[i].address = reinterpret_cast<void*>(pc);
+
+  // Make sure line termination is in place.
+  walker->frames[i].text[OS::kStackWalkMaxTextLen - 1] = '\0';
+
+  Vector<char> text = MutableCStrVector(walker->frames[i].text,
+                                        OS::kStackWalkMaxTextLen);
+
+  if (dladdr(reinterpret_cast<void*>(pc), &info) == 0) {
+    OS::SNPrintF(text, "[0x%p]", pc);
+  } else if ((info.dli_fname != NULL && info.dli_sname != NULL)) {
+    // We have symbol info.
+    OS::SNPrintF(text, "%s'%s+0x%x", info.dli_fname, info.dli_sname, pc);
+  } else {
+    // No local symbol info.
+    OS::SNPrintF(text,
+                 "%s'0x%p [0x%p]",
+                 info.dli_fname,
+                 pc - reinterpret_cast<uintptr_t>(info.dli_fbase),
+                 pc);
   }
+  walker->index++;
+  return 0;
+}
+
 
-  DeleteArray(addresses);
-  free(symbols);
+int OS::StackWalk(Vector<OS::StackFrame> frames) {
+  ucontext_t ctx;
+  struct StackWalker walker = { frames, 0 };
+
+  if (getcontext(&ctx) < 0) return kStackWalkError;
+
+  if (!walkcontext(&ctx, StackWalkCallback, &walker)) {
+    return kStackWalkError;
+  }
 
-  return frames_count;
+  return walker.index;
 }
 
 

data/ext/v8/upstream/{2.1.10 → 2.3.3}/src/platform-win32.cc

@@ -1249,16 +1249,16 @@ int OS::StackWalk(Vector<OS::StackFrame> frames) {
 
     // Try to locate a symbol for this frame.
     DWORD64 symbol_displacement;
-    IMAGEHLP_SYMBOL64* symbol = NULL;
-    symbol = NewArray<IMAGEHLP_SYMBOL64>(kStackWalkMaxNameLen);
-    if (!symbol) return kStackWalkError;  // Out of memory.
-    memset(symbol, 0, sizeof(IMAGEHLP_SYMBOL64) + kStackWalkMaxNameLen);
-    symbol->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL64);
-    symbol->MaxNameLength = kStackWalkMaxNameLen;
+    SmartPointer<IMAGEHLP_SYMBOL64> symbol(
+        NewArray<IMAGEHLP_SYMBOL64>(kStackWalkMaxNameLen));
+    if (symbol.is_empty()) return kStackWalkError;  // Out of memory.
+    memset(*symbol, 0, sizeof(IMAGEHLP_SYMBOL64) + kStackWalkMaxNameLen);
+    (*symbol)->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL64);
+    (*symbol)->MaxNameLength = kStackWalkMaxNameLen;
     ok = _SymGetSymFromAddr64(process_handle,             // hProcess
                               stack_frame.AddrPC.Offset,  // Address
                               &symbol_displacement,       // Displacement
-                              symbol);                    // Symbol
+                              *symbol);                   // Symbol
     if (ok) {
       // Try to locate more source information for the symbol.
       IMAGEHLP_LINE64 Line;
@@ -1276,13 +1276,13 @@ int OS::StackWalk(Vector<OS::StackFrame> frames) {
         SNPrintF(MutableCStrVector(frames[frames_count].text,
                                    kStackWalkMaxTextLen),
                  "%s %s:%d:%d",
-                 symbol->Name, Line.FileName, Line.LineNumber,
+                 (*symbol)->Name, Line.FileName, Line.LineNumber,
                  line_displacement);
       } else {
         SNPrintF(MutableCStrVector(frames[frames_count].text,
                                    kStackWalkMaxTextLen),
                  "%s",
-                 symbol->Name);
+                 (*symbol)->Name);
       }
       // Make sure line termination is in place.
       frames[frames_count].text[kStackWalkMaxTextLen - 1] = '\0';
@@ -1294,11 +1294,9 @@ int OS::StackWalk(Vector<OS::StackFrame> frames) {
       // module will never be found).
       int err = GetLastError();
       if (err != ERROR_MOD_NOT_FOUND) {
-        DeleteArray(symbol);
         break;
       }
     }
-    DeleteArray(symbol);
 
     frames_count++;
   }
@@ -1342,6 +1340,12 @@ int OS::ActivationFrameAlignment() {
 }
 
 
+void OS::ReleaseStore(volatile AtomicWord* ptr, AtomicWord value) {
+  MemoryBarrier();
+  *ptr = value;
+}
+
+
 bool VirtualMemory::IsReserved() {
   return address_ != NULL;
 }