Merge last PGO-green inbound changeset to m-c.
authorRyan VanderMeulen <ryanvm@gmail.com>
Sat, 19 May 2012 21:27:52 -0400
changeset 94451 f16bcf1fbf73576e9ab920f18b151fc7ee9631d8
parent 94434 a0d9e03ba59f310227df85d718858f786b482d02 (current diff)
parent 94450 da3c5b7c2c7e8b34f789c67ce870bfa16460df9e (diff)
child 94455 0e2cc686b07b32b0e05f2b021a19230abf654df2
push id22715
push userryanvm@gmail.com
push dateSun, 20 May 2012 01:28:08 +0000
treeherdermozilla-central@f16bcf1fbf73 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
milestone15.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Merge last PGO-green inbound changeset to m-c.
build/mobile/robocop/robotium-solo-3.1.jar
--- a/build/mobile/robocop/Makefile.in
+++ b/build/mobile/robocop/Makefile.in
@@ -40,17 +40,17 @@ topsrcdir   = @top_srcdir@
 srcdir      = @srcdir@
 VPATH       = @srcdir@
 TESTPATH    = $(topsrcdir)/mobile/android/base/tests
 
 include $(DEPTH)/config/autoconf.mk
 
 MODULE = robocop
 
-ROBOTIUM_PATH = $(srcdir)/robotium-solo-3.1.jar
+ROBOTIUM_PATH = $(srcdir)/robotium-solo-3.2.1.jar
 
 JAVAFILES = \
   R.java \
 
 _JAVA_HARNESS = \
   Actions.java \
   Assert.java \
   Driver.java \
--- a/build/mobile/robocop/README
+++ b/build/mobile/robocop/README
@@ -1,9 +1,9 @@
 Robocop is a Mozilla project which uses Robotium to test Firefox on Android devices.
 
 Robotium is an open source tool licensed under the Apache 2.0 license and the original 
 source can be found here:
 http://code.google.com/p/robotium/
 
-We are including robotium-solo-3.1.jar as a binary and are not modifying it in anyway 
+We are including robotium-solo-3.2.1.jar as a binary and are not modifying it in anyway 
 from the original download found at: 
 http://code.google.com/p/robotium/
deleted file mode 100644
index 0ba05859b90a8c29ca519e228674db9aebe69d90..0000000000000000000000000000000000000000
GIT binary patch
literal 0
Hc$@<O00001
new file mode 100644
index 0000000000000000000000000000000000000000..f4107c7496ec18d7a5fc2fe56742036ef3861bb7
GIT binary patch
literal 52121
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
--- a/config/expandlibs_exec.py
+++ b/config/expandlibs_exec.py
@@ -120,17 +120,17 @@ class ExpandArgsMore(ExpandArgs):
     def makelist(self):
         '''Replaces object file names with a temporary list file, using a
         list format depending on the EXPAND_LIBS_LIST_STYLE variable
         '''
         objs = [o for o in self if isObject(o)]
         if not len(objs): return
         fd, tmp = tempfile.mkstemp(suffix=".list",dir=os.curdir)
         if conf.EXPAND_LIBS_LIST_STYLE == "linkerscript":
-            content = ["INPUT(%s)\n" % obj for obj in objs]
+            content = ['INPUT("%s")\n' % obj for obj in objs]
             ref = tmp
         elif conf.EXPAND_LIBS_LIST_STYLE == "list":
             content = ["%s\n" % obj for obj in objs]
             ref = "@" + tmp
         else:
             os.close(fd)
             os.remove(tmp)
             return
--- a/config/tests/unit-expandlibs.py
+++ b/config/tests/unit-expandlibs.py
@@ -232,17 +232,17 @@ class TestExpandArgsMore(TestExpandInit)
             self.assertRelEqual(args[:3], ['foo', '-bar'] + self.files[:1])
             self.assertRelEqual(args[4:], [self.files[3]] + self.files[5:] + [self.tmpfile('liby', Lib('z'))])
 
             # Check the list file content
             objs = [f for f in self.files + self.liby_files + self.libx_files if f.endswith(config.OBJ_SUFFIX)]
             if config.EXPAND_LIBS_LIST_STYLE == "linkerscript":
                 self.assertNotEqual(args[3][0], '@')
                 filename = args[3]
-                content = ["INPUT(%s)" % relativize(f) for f in objs]
+                content = ['INPUT("%s")' % relativize(f) for f in objs]
                 with open(filename, 'r') as f:
                     self.assertEqual([l.strip() for l in f.readlines() if len(l.strip())], content)
             elif config.EXPAND_LIBS_LIST_STYLE == "list":
                 self.assertEqual(args[3][0], '@')
                 filename = args[3][1:]
                 content = objs
                 with open(filename, 'r') as f:
                     self.assertRelEqual([l.strip() for l in f.readlines() if len(l.strip())], content)
--- a/content/svg/content/src/DOMSVGStringList.cpp
+++ b/content/svg/content/src/DOMSVGStringList.cpp
@@ -213,14 +213,14 @@ DOMSVGStringList::AppendItem(const nsASt
   return InsertItemBefore(newItem, InternalList().Length(), _retval);
 }
 
 SVGStringList &
 DOMSVGStringList::InternalList()
 {
   if (mIsConditionalProcessingAttribute) {
     nsCOMPtr<DOMSVGTests> tests = do_QueryInterface(mElement);
-    return tests->mStringListAttributes[mAttrEnum];
+    return *tests->GetStringListAttribute(mAttrEnum);
   }
   return mElement->GetStringListInfo().mStringLists[mAttrEnum];
 }
 
 } // namespace mozilla
--- a/content/svg/content/src/DOMSVGTests.cpp
+++ b/content/svg/content/src/DOMSVGTests.cpp
@@ -32,16 +32,17 @@
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "DOMSVGTests.h"
 #include "DOMSVGStringList.h"
+#include "nsContentErrors.h" // For NS_PROPTABLE_PROP_OVERWRITTEN
 #include "nsSVGFeatures.h"
 #include "nsSVGSwitchElement.h"
 #include "nsCharSeparatedTokenizer.h"
 #include "nsStyleUtil.h"
 #include "nsSVGUtils.h"
 #include "mozilla/Preferences.h"
 
 using namespace mozilla;
@@ -50,48 +51,43 @@ NS_IMPL_ISUPPORTS1(DOMSVGTests, nsIDOMSV
 
 nsIAtom** DOMSVGTests::sStringListNames[3] =
 {
   &nsGkAtoms::requiredFeatures,
   &nsGkAtoms::requiredExtensions,
   &nsGkAtoms::systemLanguage,
 };
 
-DOMSVGTests::DOMSVGTests()
-{
-  mStringListAttributes[LANGUAGE].SetIsCommaSeparated(true);
-}
-
 /* readonly attribute nsIDOMSVGStringList requiredFeatures; */
 NS_IMETHODIMP
 DOMSVGTests::GetRequiredFeatures(nsIDOMSVGStringList * *aRequiredFeatures)
 {
   nsCOMPtr<nsSVGElement> element = do_QueryInterface(this);
   *aRequiredFeatures = DOMSVGStringList::GetDOMWrapper(
-                         &mStringListAttributes[FEATURES], element, true, FEATURES).get();
+                         GetOrCreateStringListAttribute(FEATURES), element, true, FEATURES).get();
   return NS_OK;
 }
 
 /* readonly attribute nsIDOMSVGStringList requiredExtensions; */
 NS_IMETHODIMP
 DOMSVGTests::GetRequiredExtensions(nsIDOMSVGStringList * *aRequiredExtensions)
 {
   nsCOMPtr<nsSVGElement> element = do_QueryInterface(this);
   *aRequiredExtensions = DOMSVGStringList::GetDOMWrapper(
-                           &mStringListAttributes[EXTENSIONS], element, true, EXTENSIONS).get();
+                           GetOrCreateStringListAttribute(EXTENSIONS), element, true, EXTENSIONS).get();
   return NS_OK;
 }
 
 /* readonly attribute nsIDOMSVGStringList systemLanguage; */
 NS_IMETHODIMP
 DOMSVGTests::GetSystemLanguage(nsIDOMSVGStringList * *aSystemLanguage)
 {
   nsCOMPtr<nsSVGElement> element = do_QueryInterface(this);
   *aSystemLanguage = DOMSVGStringList::GetDOMWrapper(
-                       &mStringListAttributes[LANGUAGE], element, true, LANGUAGE).get();
+                       GetOrCreateStringListAttribute(LANGUAGE), element, true, LANGUAGE).get();
   return NS_OK;
 }
 
 /* boolean hasExtension (in DOMString extension); */
 NS_IMETHODIMP
 DOMSVGTests::HasExtension(const nsAString & extension, bool *_retval)
 {
   *_retval = nsSVGFeatures::HasExtension(extension);
@@ -111,25 +107,29 @@ DOMSVGTests::IsConditionalProcessingAttr
 
 PRInt32
 DOMSVGTests::GetBestLanguagePreferenceRank(const nsSubstring& aAcceptLangs) const
 {
   const nsDefaultStringComparator defaultComparator;
 
   PRInt32 lowestRank = -1;
 
-  for (PRUint32 i = 0; i < mStringListAttributes[LANGUAGE].Length(); i++) {
+  const SVGStringList *languageStringList = GetStringListAttribute(LANGUAGE);
+  if (!languageStringList) {
+    return lowestRank;
+  }
+  for (PRUint32 i = 0; i < languageStringList->Length(); i++) {
     nsCharSeparatedTokenizer languageTokenizer(aAcceptLangs, ',');
     PRInt32 index = 0;
     while (languageTokenizer.hasMoreTokens()) {
       const nsSubstring &languageToken = languageTokenizer.nextToken();
-      bool exactMatch = (languageToken == mStringListAttributes[LANGUAGE][i]);
+      bool exactMatch = (languageToken == (*languageStringList)[i]);
       bool prefixOnlyMatch =
         !exactMatch &&
-        nsStyleUtil::DashMatchCompare(mStringListAttributes[LANGUAGE][i],
+        nsStyleUtil::DashMatchCompare((*languageStringList)[i],
                                       languageTokenizer.nextToken(),
                                       defaultComparator);
       if (index == 0 && exactMatch) {
         // best possible match
         return 0;
       }
       if ((exactMatch || prefixOnlyMatch) &&
           (lowestRank == -1 || 2 * index + prefixOnlyMatch < lowestRank)) {
@@ -142,79 +142,82 @@ DOMSVGTests::GetBestLanguagePreferenceRa
 }
 
 const nsString * const DOMSVGTests::kIgnoreSystemLanguage = (nsString *) 0x01;
 
 bool
 DOMSVGTests::PassesConditionalProcessingTests(const nsString *aAcceptLangs) const
 {
   // Required Features
-  if (mStringListAttributes[FEATURES].IsExplicitlySet()) {
-    if (mStringListAttributes[FEATURES].IsEmpty()) {
+  const SVGStringList *featuresStringList = GetStringListAttribute(FEATURES);
+  if (featuresStringList && featuresStringList->IsExplicitlySet()) {
+    if (featuresStringList->IsEmpty()) {
       return false;
     }
     nsCOMPtr<nsIContent> content(
       do_QueryInterface(const_cast<DOMSVGTests*>(this)));
 
-    for (PRUint32 i = 0; i < mStringListAttributes[FEATURES].Length(); i++) {
-      if (!nsSVGFeatures::HasFeature(content, mStringListAttributes[FEATURES][i])) {
+    for (PRUint32 i = 0; i < featuresStringList->Length(); i++) {
+      if (!nsSVGFeatures::HasFeature(content, (*featuresStringList)[i])) {
         return false;
       }
     }
   }
 
   // Required Extensions
   //
   // The requiredExtensions  attribute defines a list of required language
   // extensions. Language extensions are capabilities within a user agent that
   // go beyond the feature set defined in the SVG specification.
   // Each extension is identified by a URI reference.
   // For now, claim that mozilla's SVG implementation supports XHTML and MathML.
-  if (mStringListAttributes[EXTENSIONS].IsExplicitlySet()) {
-    if (mStringListAttributes[EXTENSIONS].IsEmpty()) {
+  const SVGStringList *extensionsStringList = GetStringListAttribute(EXTENSIONS);
+  if (extensionsStringList && extensionsStringList->IsExplicitlySet()) {
+    if (extensionsStringList->IsEmpty()) {
       return false;
     }
-    for (PRUint32 i = 0; i < mStringListAttributes[EXTENSIONS].Length(); i++) {
-      if (!nsSVGFeatures::HasExtension(mStringListAttributes[EXTENSIONS][i])) {
+    for (PRUint32 i = 0; i < extensionsStringList->Length(); i++) {
+      if (!nsSVGFeatures::HasExtension((*extensionsStringList)[i])) {
         return false;
       }
     }
   }
 
   if (aAcceptLangs == kIgnoreSystemLanguage) {
     return true;
   }
 
   // systemLanguage
   //
   // Evaluates to "true" if one of the languages indicated by user preferences
   // exactly equals one of the languages given in the value of this parameter,
   // or if one of the languages indicated by user preferences exactly equals a
   // prefix of one of the languages given in the value of this parameter such
   // that the first tag character following the prefix is "-".
-  if (mStringListAttributes[LANGUAGE].IsExplicitlySet()) {
-    if (mStringListAttributes[LANGUAGE].IsEmpty()) {
+  const SVGStringList *languageStringList = GetStringListAttribute(LANGUAGE);
+  if (languageStringList && languageStringList->IsExplicitlySet()) {
+    if (languageStringList->IsEmpty()) {
       return false;
     }
 
     // Get our language preferences
     const nsAutoString acceptLangs(aAcceptLangs ? *aAcceptLangs :
       Preferences::GetLocalizedString("intl.accept_languages"));
 
     if (acceptLangs.IsEmpty()) {
       NS_WARNING("no default language specified for systemLanguage conditional test");
       return false;
     }
 
     const nsDefaultStringComparator defaultComparator;
 
-    for (PRUint32 i = 0; i < mStringListAttributes[LANGUAGE].Length(); i++) {
+    for (PRUint32 i = 0; i < languageStringList->Length(); i++) {
       nsCharSeparatedTokenizer languageTokenizer(acceptLangs, ',');
       while (languageTokenizer.hasMoreTokens()) {
-        if (nsStyleUtil::DashMatchCompare(mStringListAttributes[LANGUAGE][i],
+        if (nsStyleUtil::DashMatchCompare((*languageStringList)[i],
                                           languageTokenizer.nextToken(),
                                           defaultComparator)) {
           return true;
         }
       }
     }
     return false;
   }
@@ -224,51 +227,109 @@ DOMSVGTests::PassesConditionalProcessing
 
 bool
 DOMSVGTests::ParseConditionalProcessingAttribute(nsIAtom* aAttribute,
                                                  const nsAString& aValue,
                                                  nsAttrValue& aResult)
 {
   for (PRUint32 i = 0; i < ArrayLength(sStringListNames); i++) {
     if (aAttribute == *sStringListNames[i]) {
-      nsresult rv = mStringListAttributes[i].SetValue(aValue);
-      if (NS_FAILED(rv)) {
-        mStringListAttributes[i].Clear();
+      SVGStringList *stringList = GetOrCreateStringListAttribute(i);
+      if (stringList) {
+        nsresult rv = stringList->SetValue(aValue);
+        if (NS_FAILED(rv)) {
+          stringList->Clear();
+        }
       }
       MaybeInvalidate();
       return true;
     }
   }
   return false;
 }
 
 void
 DOMSVGTests::UnsetAttr(const nsIAtom* aAttribute)
 {
   for (PRUint32 i = 0; i < ArrayLength(sStringListNames); i++) {
     if (aAttribute == *sStringListNames[i]) {
-      mStringListAttributes[i].Clear();
-      MaybeInvalidate();
+      SVGStringList *stringList = GetStringListAttribute(i);
+      if (stringList) {
+        // don't destroy the property in case there are tear-offs
+        // referring to it
+        stringList->Clear();
+        MaybeInvalidate();
+      }
       return;
     }
   }
 }
 
+// Callback function, for freeing PRUint64 values stored in property table
+// when the element goes away
+static void
+ReleaseStringListPropertyValue(void*    aObject,       /* unused */
+                               nsIAtom* aPropertyName, /* unused */
+                               void*    aPropertyValue,
+                               void*    aData          /* unused */)
+{
+  SVGStringList* valPtr =
+    static_cast<SVGStringList*>(aPropertyValue);
+  delete valPtr;
+}
+
+SVGStringList*
+DOMSVGTests::GetStringListAttribute(PRUint8 aAttrEnum) const
+{
+  nsIAtom *attrName = GetAttrName(aAttrEnum);
+  const nsCOMPtr<nsSVGElement> element =
+    do_QueryInterface(const_cast<DOMSVGTests*>(this));
+
+  return static_cast<SVGStringList*>(element->GetProperty(attrName));
+}
+
+SVGStringList*
+DOMSVGTests::GetOrCreateStringListAttribute(PRUint8 aAttrEnum) const
+{
+  SVGStringList* stringListPtr = GetStringListAttribute(aAttrEnum);
+  if (stringListPtr) {
+    return stringListPtr;
+  }
+  nsIAtom *attrName = GetAttrName(aAttrEnum);
+  const nsCOMPtr<nsSVGElement> element =
+    do_QueryInterface(const_cast<DOMSVGTests*>(this));
+
+  stringListPtr = new SVGStringList();
+  stringListPtr->SetIsCommaSeparated(aAttrEnum == LANGUAGE);
+  nsresult rv = element->SetProperty(attrName,
+                                     stringListPtr,
+                                     ReleaseStringListPropertyValue);
+  NS_ABORT_IF_FALSE(rv != NS_PROPTABLE_PROP_OVERWRITTEN,
+                    "Setting property value when it's already set...?"); 
+
+  if (NS_LIKELY(NS_SUCCEEDED(rv))) {
+    return stringListPtr;
+  }
+  // property-insertion failed (e.g. OOM in property-table code)
+  delete stringListPtr;
+  return nsnull;
+}
+
 nsIAtom*
 DOMSVGTests::GetAttrName(PRUint8 aAttrEnum) const
 {
   return *sStringListNames[aAttrEnum];
 }
 
 void
 DOMSVGTests::GetAttrValue(PRUint8 aAttrEnum, nsAttrValue& aValue) const
 {
   MOZ_ASSERT(aAttrEnum < ArrayLength(sStringListNames),
              "aAttrEnum out of range");
-  aValue.SetTo(mStringListAttributes[aAttrEnum], nsnull);
+  aValue.SetTo(*GetOrCreateStringListAttribute(aAttrEnum), nsnull);
 }
 
 void
 DOMSVGTests::MaybeInvalidate()
 {
   nsCOMPtr<nsSVGElement> element = do_QueryInterface(this);
 
   nsIContent* parent = element->GetFlattenedTreeParent();
--- a/content/svg/content/src/DOMSVGTests.h
+++ b/content/svg/content/src/DOMSVGTests.h
@@ -54,18 +54,16 @@ class DOMSVGTests : public nsIDOMSVGTest
 {
 public:
   NS_DECL_ISUPPORTS
   NS_DECL_NSIDOMSVGTESTS
 
   friend class mozilla::DOMSVGStringList;
   typedef mozilla::SVGStringList SVGStringList;
 
-  DOMSVGTests();
-
   /**
    * Compare the language name(s) in a systemLanguage attribute to the
    * user's language preferences, as defined in
    * http://www.w3.org/TR/SVG11/struct.html#SystemLanguageAttribute
    * We have a match if a language name in the users language preferences
    * exactly equals one of the language names or exactly equals a prefix of
    * one of the language names in the systemLanguage attribute.
    * @returns 2 * the lowest index in the aAcceptLangs that matches + 1
@@ -106,19 +104,20 @@ public:
          nsAttrValue& aResult);
 
   /**
    * Unsets a conditional processing attribute.
    */
   void UnsetAttr(const nsIAtom* aAttribute);
 
   nsIAtom* GetAttrName(PRUint8 aAttrEnum) const;
+  SVGStringList* GetStringListAttribute(PRUint8 aAttrEnum) const;
+  SVGStringList* GetOrCreateStringListAttribute(PRUint8 aAttrEnum) const;
   void GetAttrValue(PRUint8 aAttrEnum, nsAttrValue &aValue) const;
 
   void MaybeInvalidate();
 
 private:
   enum { FEATURES, EXTENSIONS, LANGUAGE };
-  SVGStringList mStringListAttributes[3];
   static nsIAtom** sStringListNames[3];
 };
 
 #endif // MOZILLA_DOMSVGTESTS_H__
--- a/ipc/ril/Ril.cpp
+++ b/ipc/ril/Ril.cpp
@@ -315,21 +315,29 @@ RilClient::OnFileCanWriteWithoutBlocking
     //
     // Otherwise, save the byte position of the next byte to write
     // within mCurrentRilRawData, and request another write when the
     // system won't block.
     //
 
     MOZ_ASSERT(fd == mSocket.get());
 
-    while (!mOutgoingQ.empty() || mCurrentRilRawData != NULL) {
-        if(!mCurrentRilRawData) {
-            mCurrentRilRawData = mOutgoingQ.front();
-            mOutgoingQ.pop();
-            mCurrentWriteOffset = 0;
+    while (true) {
+        {
+            MutexAutoLock lock(mMutex);
+
+            if (mOutgoingQ.empty() && !mCurrentRilRawData) {
+                return;
+            }
+
+            if(!mCurrentRilRawData) {
+                mCurrentRilRawData = mOutgoingQ.front();
+                mOutgoingQ.pop();
+                mCurrentWriteOffset = 0;
+            }
         }
         const uint8_t *toWrite;
 
         toWrite = mCurrentRilRawData->mData;
  
         while (mCurrentWriteOffset < mCurrentRilRawData->mSize) {
             ssize_t write_amount = mCurrentRilRawData->mSize - mCurrentWriteOffset;
             ssize_t written;
--- a/js/src/Makefile.in
+++ b/js/src/Makefile.in
@@ -66,17 +66,17 @@ endif
 
 TEST_DIRS += tests
 
 MODULE		    = js
 LIBRARY_NAME	    = mozjs
 STATIC_LIBRARY_NAME = js_static
 GRE_MODULE	    = 1
 
-LIBS		= $(NSPR_LIBS) 
+LIBS		= $(NSPR_LIBS)
 
 ifeq ($(OS_ARCH),WINNT)
 NO_PROFILE_GUIDED_OPTIMIZE = 1
 endif
 
 # JavaScript must be built shared, even for static builds, as it is used by
 # other modules which are always built shared. Failure to do so results in
 # the js code getting copied into xpinstall and jsd as well as mozilla-bin,
@@ -634,17 +634,17 @@ check-jstests:
 # We want to run check-jstests as part of |make check| on all platforms, on
 # tinderbox. However, some configurations don't work quite right just yet.
 # Rather than risking regressions in major configurations while fixing these
 # secondary configuration, we work around them and fix the bugs later.
 #
 #   Bug 652154: On Windows, SM(!m !t) don't work because of path problems with
 #				their unusual directory layout
 #
-#   Bug 652155: On Mac, SM(d) doesn't work for unknown reasons 
+#   Bug 652155: On Mac, SM(d) doesn't work for unknown reasons
 
 ifeq ($(OS_ARCH),WINNT)
 ifdef ENABLE_METHODJIT
 endif
 else
 ifndef HAVE_DTRACE
 #check:: check-jstests
 endif
@@ -762,17 +762,17 @@ jsdtoa.o: jsdtoa.cpp Makefile.in
 endif
 
 # Compute the linker flags that programs linking against SpiderMonkey should
 # pass to get SpiderMonkey and its dependencies, beyond just the -L and -l
 # for the SpiderMonkey library itself.
 # - EXTRA_DSO_LDOPTS includes the NSPR -L and -l flags.
 # - OS_LIBS includes libraries selected by the configure script.
 # - EXTRA_LIBS includes libraries selected by this Makefile.
-JS_CONFIG_LIBS=$(EXTRA_DSO_LDOPTS) $(OS_LIBS) $(EXTRA_LIBS) 
+JS_CONFIG_LIBS=$(EXTRA_DSO_LDOPTS) $(OS_LIBS) $(EXTRA_LIBS)
 
 # The configure script invokes this rule explicitly at configure time!
 # It's important that js-config be ready by the time we're done
 # configuring, because we may be running other configure scripts that
 # would like to run js-config themselves, before js is built.
 #
 # This file and rules.mk go through a certain amount of work to decide
 # which libraries to build, what to name them, and what flags to pass
--- a/js/src/MemoryMetrics.cpp
+++ b/js/src/MemoryMetrics.cpp
@@ -181,31 +181,31 @@ StatsCellCallback(JSRuntime *rt, void *d
     cStats->gcHeapArenaUnused -= thingSize;
 }
 
 JS_PUBLIC_API(bool)
 CollectRuntimeStats(JSRuntime *rt, RuntimeStats *rtStats)
 {
     if (!rtStats->compartmentStatsVector.reserve(rt->compartments.length()))
         return false;
-    
+
     rtStats->gcHeapChunkCleanDecommitted =
         rt->gcChunkPool.countCleanDecommittedArenas(rt) * gc::ArenaSize;
     rtStats->gcHeapChunkCleanUnused =
         size_t(JS_GetGCParameter(rt, JSGC_UNUSED_CHUNKS)) * gc::ChunkSize -
         rtStats->gcHeapChunkCleanDecommitted;
     rtStats->gcHeapChunkTotal =
         size_t(JS_GetGCParameter(rt, JSGC_TOTAL_CHUNKS)) * gc::ChunkSize;
-    
+
     IterateCompartmentsArenasCells(rt, rtStats, StatsCompartmentCallback,
                                    StatsArenaCallback, StatsCellCallback);
     IterateChunks(rt, rtStats, StatsChunkCallback);
-    
+
     rt->sizeOfIncludingThis(rtStats->mallocSizeOf, &rtStats->runtime);
-    
+
     // This is initialized to all bytes stored in used chunks, and then we
     // subtract used space from it each time around the loop.
     rtStats->gcHeapChunkDirtyUnused = rtStats->gcHeapChunkTotal -
                                       rtStats->gcHeapChunkCleanUnused -
                                       rtStats->gcHeapChunkCleanDecommitted -
                                       rtStats->gcHeapChunkDirtyDecommitted;
 
     rtStats->totalMjit = rtStats->runtime.mjitCode;
--- a/js/src/README.html
+++ b/js/src/README.html
@@ -5,27 +5,27 @@
    - 1.1 (the "License"); you may not use this file except in compliance with
    - the License. You may obtain a copy of the License at
    - http://www.mozilla.org/MPL/
    -
    - Software distributed under the License is distributed on an "AS IS" basis,
    - WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
    - for the specific language governing rights and limitations under the
    - License.
-   - 
+   -
    - The Original Code is Mozilla Communicator client code, released
    - March 31, 1998.
-   - 
+   -
    - The Initial Developer of the Original Code is
    - Netscape Communications Corporation.
    - Portions created by the Initial Developer are Copyright (C) 1998-1999
    - the Initial Developer. All Rights Reserved.
-   - 
+   -
    - Contributor(s):
-   - 
+   -
    - Alternatively, the contents of this file may be used under the terms of
    - either of the GNU General Public License Version 2 or later (the "GPL"),
    - or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
    - in which case the provisions of the GPL or the LGPL are applicable instead
    - of those above. If you wish to allow use of your version of this file only
    - under the terms of either the GPL or the LGPL, and not to allow others to
    - use your version of this file under the terms of the MPL, indicate your
    - decision by deleting the provisions above and replace them with the notice
--- a/js/src/aclocal.m4
+++ b/js/src/aclocal.m4
@@ -1,12 +1,12 @@
 dnl
 dnl Local autoconf macros used with mozilla
 dnl The contents of this file are under the Public Domain.
-dnl 
+dnl
 
 builtin(include, build/autoconf/pkg.m4)dnl
 builtin(include, build/autoconf/nspr.m4)dnl
 builtin(include, build/autoconf/altoptions.m4)dnl
 builtin(include, build/autoconf/moznbytetype.m4)dnl
 builtin(include, build/autoconf/mozprog.m4)dnl
 builtin(include, build/autoconf/mozheader.m4)dnl
 builtin(include, build/autoconf/mozcommonheader.m4)dnl
--- a/js/src/builtin/RegExp.h
+++ b/js/src/builtin/RegExp.h
@@ -48,17 +48,17 @@ js_InitRegExpClass(JSContext *cx, JSObje
 
 /*
  * The following builtin natives are extern'd for pointer comparison in
  * other parts of the engine.
  */
 
 namespace js {
 
-/* 
+/*
  * |res| may be null if the |RegExpStatics| are not to be updated.
  * |input| may be null if there is no |JSString| corresponding to
  * |chars| and |length|.
  */
 bool
 ExecuteRegExp(JSContext *cx, RegExpStatics *res, RegExpObject &reobj,
               JSLinearString *input, const jschar *chars, size_t length,
               size_t *lastIndex, RegExpExecType type, Value *rval);
--- a/js/src/config/expandlibs_exec.py
+++ b/js/src/config/expandlibs_exec.py
@@ -120,17 +120,17 @@ class ExpandArgsMore(ExpandArgs):
     def makelist(self):
         '''Replaces object file names with a temporary list file, using a
         list format depending on the EXPAND_LIBS_LIST_STYLE variable
         '''
         objs = [o for o in self if isObject(o)]
         if not len(objs): return
         fd, tmp = tempfile.mkstemp(suffix=".list",dir=os.curdir)
         if conf.EXPAND_LIBS_LIST_STYLE == "linkerscript":
-            content = ["INPUT(%s)\n" % obj for obj in objs]
+            content = ['INPUT("%s")\n' % obj for obj in objs]
             ref = tmp
         elif conf.EXPAND_LIBS_LIST_STYLE == "list":
             content = ["%s\n" % obj for obj in objs]
             ref = "@" + tmp
         else:
             os.close(fd)
             os.remove(tmp)
             return
--- a/js/src/configure.in
+++ b/js/src/configure.in
@@ -1643,17 +1643,17 @@ if test "$GNU_CC"; then
     # -Werror=return-type - catches missing returns, zero false positives
     # -Wtype-limits - catches overflow bugs, few false positives
     # -Wempty-body - catches bugs, e.g. "if (c); foo();", few false positives
     #
     _WARNINGS_CFLAGS="${_WARNINGS_CFLAGS} -Wall -Wpointer-arith -Wdeclaration-after-statement"
     MOZ_C_SUPPORTS_WARNING(-W, error=return-type, ac_c_has_werror_return_type)
     MOZ_C_SUPPORTS_WARNING(-W, type-limits, ac_c_has_wtype_limits)
     MOZ_C_SUPPORTS_WARNING(-W, empty-body, ac_c_has_wempty_body)
-    
+
     # Turn off the following warnings that -Wall/-pedantic turn on:
     # -Wno-unused - lots of violations in third-party code
     # -Wno-overlength-strings - we exceed the minimum maximum length frequently
     #
     _WARNINGS_CFLAGS="${_WARNINGS_CFLAGS} -Wno-unused"
     MOZ_C_SUPPORTS_WARNING(-Wno-, overlength-strings, ac_c_has_wno_overlength_strings)
 
     if test -z "$INTEL_CC" -a -z "$CLANG_CC"; then
--- a/js/src/frontend/BytecodeEmitter.h
+++ b/js/src/frontend/BytecodeEmitter.h
@@ -150,17 +150,17 @@ struct BytecodeEmitter
     typedef Vector<uint32_t, 8> SlotVector;
     SlotVector      closedArgs;
     SlotVector      closedVars;
 
     uint16_t        typesetCount;   /* Number of JOF_TYPESET opcodes generated */
 
     /* These two should only be true if sc->inFunction() is false. */
     const bool      noScriptRval:1;     /* The caller is JS_Compile*Script*. */
-    const bool      needScriptGlobal:1; /* API caller does not want result value 
+    const bool      needScriptGlobal:1; /* API caller does not want result value
                                            from global script. */
 
     bool            hasSingletons:1;    /* script contains singleton initializer JSOP_OBJECT */
 
     BytecodeEmitter(Parser *parser, SharedContext *sc, unsigned lineno,
                     bool noScriptRval, bool needScriptGlobal);
     bool init();
 
--- a/js/src/frontend/ParseNode.cpp
+++ b/js/src/frontend/ParseNode.cpp
@@ -121,17 +121,17 @@ FunctionBox::inAnyDynamicScope() const
 
 /* Add |node| to |parser|'s free node list. */
 void
 ParseNodeAllocator::freeNode(ParseNode *pn)
 {
     /* Catch back-to-back dup recycles. */
     JS_ASSERT(pn != freelist);
 
-    /* 
+    /*
      * It's too hard to clear these nodes from the AtomDefnMaps, etc. that
      * hold references to them, so we never free them. It's our caller's job to
      * recognize and process these, since their children do need to be dealt
      * with.
      */
     JS_ASSERT(!pn->isUsed());
     JS_ASSERT(!pn->isDefn());
 
@@ -246,17 +246,17 @@ PushNodeChildren(ParseNode *pn, NodeStac
         if (pn->pn_left != pn->pn_right)
             stack->pushUnlessNull(pn->pn_left);
         stack->pushUnlessNull(pn->pn_right);
         break;
       case PN_UNARY:
         stack->pushUnlessNull(pn->pn_kid);
         break;
       case PN_NULLARY:
-        /* 
+        /*
          * E4X function namespace nodes are PN_NULLARY, but can appear on use
          * lists.
          */
         return !pn->isUsed() && !pn->isDefn();
       default:
         ;
     }
 
@@ -650,14 +650,14 @@ js::CloneLeftHandSide(ParseNode *opn, Pa
     }
     return pn;
 }
 
 #ifdef DEBUG
 void
 js::DumpParseTree(ParseNode *pn, int indent)
 {
-    if (pn == NULL) 
+    if (pn == NULL)
         fprintf(stderr, "()");
     else
         pn->dump(indent);
 }
 #endif
--- a/js/src/frontend/SemanticAnalysis.cpp
+++ b/js/src/frontend/SemanticAnalysis.cpp
@@ -157,17 +157,17 @@ SetFunctionKinds(FunctionBox *funbox, bo
  * within the top statement list, which don't take effect unless they are
  * evaluated). Such call objects may acquire bindings that shadow variables
  * defined in enclosing scopes, so any enclosed functions must have their
  * bindings' extensibleParents flags set, and enclosed compiler-created blocks
  * must have their OWN_SHAPE flags set; the comments for
  * js::Bindings::extensibleParents explain why.
  */
 static bool
-MarkExtensibleScopeDescendants(JSContext *context, FunctionBox *funbox, bool hasExtensibleParent) 
+MarkExtensibleScopeDescendants(JSContext *context, FunctionBox *funbox, bool hasExtensibleParent)
 {
     for (; funbox; funbox = funbox->siblings) {
         /*
          * It would be nice to use fun->kind() here to recognize functions
          * that will never consult their parent chains, and thus don't need
          * their 'extensible parents' flag set. Filed as bug 619750.
          */
 
--- a/js/src/frontend/TreeContext.h
+++ b/js/src/frontend/TreeContext.h
@@ -94,17 +94,17 @@ class ContextFlags {
     //
     bool            bindingsAccessedDynamically:1;
 
     // The |fun*| flags are only relevant if |inFunction| is true.  Due to
     // sloppiness, however, some are set in cases where |inFunction| is
     // false.
 
     // The function needs Call object per call.
-    bool            funIsHeavyweight:1; 
+    bool            funIsHeavyweight:1;
 
     // We parsed a yield statement in the function.
     bool            funIsGenerator:1;
 
     // The function or a function that encloses it may define new local names
     // at runtime through means other than calling eval.
     bool            funMightAliasLocals:1;
 
@@ -253,20 +253,20 @@ struct SharedContext {
 
     // Return true if we need to check for conditions that elicit
     // JSOPTION_STRICT warnings or strict mode errors.
     inline bool needStrictChecks();
 };
 
 typedef HashSet<JSAtom *> FuncStmtSet;
 struct Parser;
- 
+
 struct TreeContext {                /* tree context for semantic checks */
     SharedContext   *sc;            /* context shared between parsing and bytecode generation */
- 
+
     uint32_t        parenDepth;     /* nesting depth of parens that might turn out
                                        to be generator expressions */
     uint32_t        yieldCount;     /* number of |yield| tokens encountered at
                                        non-zero depth in current paren tree */
     ParseNode       *blockNode;     /* parse node for a block with let declarations
                                        (block with its own lexical scope)  */
     AtomDecls       decls;          /* function, const, and var declarations */
     ParseNode       *yieldNode;     /* parse node for a yield expression that might
--- a/js/src/javascript-trace.d
+++ b/js/src/javascript-trace.d
@@ -37,17 +37,17 @@
  * object-finalize      (NULL, classname, *object)
  * execute-start        (filename, lineno)
  * execute-done         (filename, lineno)
  */
 
 provider javascript {
  probe function__entry(const char *, const char *, const char *);
  probe function__return(const char *, const char *, const char *);
- /* XXX must use unsigned longs here instead of uintptr_t for OS X 
+ /* XXX must use unsigned longs here instead of uintptr_t for OS X
     (Apple radar: 5194316 & 5565198) */
  probe object__create(const char *, unsigned long);
  probe object__finalize(const char *, const char *, unsigned long);
  probe execute__start(const char *, int);
  probe execute__done(const char *, int);
 };
 
 /*
--- a/js/src/js-config.in
+++ b/js/src/js-config.in
@@ -139,9 +139,9 @@ if test "$echo_libdir" = "yes"; then
 fi
 
 if test "$echo_cflags" = "yes"; then
     echo "-I$includedir/js $NSPR_CFLAGS"
 fi
 
 if test "$echo_libs" = "yes"; then
     echo "$MOZ_JS_LIBS $JS_CONFIG_LIBS"
-fi      
+fi
--- a/js/src/jsanalyze.cpp
+++ b/js/src/jsanalyze.cpp
@@ -1561,17 +1561,17 @@ ScriptAnalysis::analyzeSSA(JSContext *cx
                 pc2 += JUMP_OFFSET_LEN;
                 npairs--;
             }
 
             checkBranchTarget(cx, defaultOffset, branchTargets, values, stackDepth);
             break;
           }
 
-          case JSOP_TRY: { 
+          case JSOP_TRY: {
             JSTryNote *tn = script->trynotes()->vector;
             JSTryNote *tnlimit = tn + script->trynotes()->length;
             for (; tn < tnlimit; tn++) {
                 unsigned startOffset = script->mainOffset + tn->start;
                 if (startOffset == offset + 1) {
                     unsigned catchOffset = startOffset + tn->length;
 
                     if (tn->kind != JSTRY_ITER) {
@@ -2133,17 +2133,17 @@ ScriptAnalysis::printSSA(JSContext *cx)
 
         for (unsigned i = 0; i < xuses; i++) {
             printf("  popped%d: ", i);
             code->poppedValues[i].print();
             printf("\n");
         }
     }
 
-    printf("\n"); 
+    printf("\n");
 }
 
 void
 SSAValue::print() const
 {
     switch (kind()) {
 
       case EMPTY:
--- a/js/src/jsanalyze.h
+++ b/js/src/jsanalyze.h
@@ -886,22 +886,22 @@ class ScriptAnalysis
     uint32_t numReturnSites_;
 
     /* --------- Lifetime analysis --------- */
 
     LifetimeVariable *lifetimes;
 
   public:
 
-    ScriptAnalysis(JSScript *script) { 
+    ScriptAnalysis(JSScript *script) {
         PodZero(this);
         this->script = script;
 #ifdef DEBUG
         this->originalDebugMode_ = script->compartment()->debugMode();
-#endif        
+#endif
     }
 
     bool ranBytecode() { return ranBytecode_; }
     bool ranSSA() { return ranSSA_; }
     bool ranLifetimes() { return ranLifetimes_; }
     bool ranInference() { return ranInference_; }
 
     void analyzeBytecode(JSContext *cx);
--- a/js/src/jsapi-tests/testAddPropertyPropcache.cpp
+++ b/js/src/jsapi-tests/testAddPropertyPropcache.cpp
@@ -36,31 +36,31 @@ BEGIN_TEST(testAddPropertyHook)
     proto = OBJECT_TO_JSVAL(obj);
     JS_InitClass(cx, global, obj, &addPropertyClass, NULL, 0, NULL, NULL, NULL,
                  NULL);
 
     jsvalRoot arr(cx);
     obj = JS_NewArrayObject(cx, 0, NULL);
     CHECK(obj);
     arr = OBJECT_TO_JSVAL(obj);
-        
+
     CHECK(JS_DefineProperty(cx, global, "arr", arr,
                             JS_PropertyStub, JS_StrictPropertyStub,
                             JSPROP_ENUMERATE));
 
     for (int i = 0; i < expectedCount; ++i) {
         jsvalRoot vobj(cx);
         obj = JS_NewObject(cx, &addPropertyClass, NULL, NULL);
         CHECK(obj);
         vobj = OBJECT_TO_JSVAL(obj);
         CHECK(JS_DefineElement(cx, JSVAL_TO_OBJECT(arr), i, vobj,
                                JS_PropertyStub, JS_StrictPropertyStub,
                                JSPROP_ENUMERATE));
     }
-    
+
     // Now add a prop to each of the objects, but make sure to do
     // so at the same bytecode location so we can hit the propcache.
     EXEC("'use strict';                                     \n"
          "for (var i = 0; i < arr.length; ++i)              \n"
          "  arr[i].prop = 42;                               \n"
          );
 
     CHECK(callCount == expectedCount);
--- a/js/src/jsapi-tests/testCloneScript.cpp
+++ b/js/src/jsapi-tests/testCloneScript.cpp
@@ -9,17 +9,17 @@
 
 BEGIN_TEST(test_cloneScript)
 {
     JSObject *A, *B;
 
     CHECK(A = createGlobal());
     CHECK(B = createGlobal());
 
-    const char *source = 
+    const char *source =
         "var i = 0;\n"
         "var sum = 0;\n"
         "while (i < 10) {\n"
         "    sum += i;\n"
         "    ++i;\n"
         "}\n"
         "(sum);\n";
 
--- a/js/src/jsapi-tests/testDebugger.cpp
+++ b/js/src/jsapi-tests/testDebugger.cpp
@@ -173,17 +173,17 @@ BEGIN_TEST(testDebugger_debuggerObjectVs
         CHECK(ae.enter(cx, debuggee));
         CHECK(JS_SetDebugMode(cx, false));
     }
 
     EVAL("debuggee.eval('debugger; debugger; debugger;');\n"
          "hits;\n",
          &v);
     CHECK_SAME(v, INT_TO_JSVAL(4));
-    
+
     return true;
 }
 END_TEST(testDebugger_debuggerObjectVsDebugMode)
 
 BEGIN_TEST(testDebugger_newScriptHook)
 {
     // Test that top-level indirect eval fires the newScript hook.
     CHECK(JS_DefineDebuggerObject(cx, global));
--- a/js/src/jsapi-tests/testResolveRecursion.cpp
+++ b/js/src/jsapi-tests/testResolveRecursion.cpp
@@ -9,26 +9,26 @@
  * prevented.
  */
 
 BEGIN_TEST(testResolveRecursion)
 {
     static JSClass my_resolve_class = {
         "MyResolve",
         JSCLASS_NEW_RESOLVE | JSCLASS_HAS_PRIVATE,
-        
+
         JS_PropertyStub,       // add
         JS_PropertyStub,       // delete
         JS_PropertyStub,         // get
         JS_StrictPropertyStub, // set
         JS_EnumerateStub,
         (JSResolveOp) my_resolve,
         JS_ConvertStub
     };
-    
+
     obj1 = JS_NewObject(cx, &my_resolve_class, NULL, NULL);
     CHECK(obj1);
     obj2 = JS_NewObject(cx, &my_resolve_class, NULL, NULL);
     CHECK(obj2);
     JS_SetPrivate(obj1, this);
     JS_SetPrivate(obj2, this);
 
     CHECK(JS_DefineProperty(cx, global, "obj1", OBJECT_TO_JSVAL(obj1), NULL, NULL, 0));
@@ -47,17 +47,17 @@ BEGIN_TEST(testResolveRecursion)
 }
 
 JSObject *obj1;
 JSObject *obj2;
 unsigned resolveEntryCount;
 unsigned resolveExitCount;
 
 struct AutoIncrCounters {
-    
+
     AutoIncrCounters(cls_testResolveRecursion *t) : t(t) {
         t->resolveEntryCount++;
     }
 
     ~AutoIncrCounters() {
         t->resolveExitCount++;
     }
 
@@ -65,19 +65,19 @@ struct AutoIncrCounters {
 };
 
 bool
 doResolve(JSObject *obj, jsid id, unsigned flags, JSObject **objp)
 {
     CHECK_EQUAL(resolveExitCount, 0);
     AutoIncrCounters incr(this);
     CHECK_EQUAL(obj, obj1 || obj == obj2);
-    
+
     CHECK(JSID_IS_STRING(id));
-    
+
     JSFlatString *str = JS_FlattenString(cx, JSID_TO_STRING(id));
     CHECK(str);
     jsval v;
     if (JS_FlatStringEqualsAscii(str, "x")) {
         if (obj == obj1) {
             /* First resolve hook invocation. */
             CHECK_EQUAL(resolveEntryCount, 1);
             EVAL("obj2.y = true", &v);
--- a/js/src/jsapi-tests/testSlowScript.cpp
+++ b/js/src/jsapi-tests/testSlowScript.cpp
@@ -52,17 +52,17 @@ BEGIN_TEST(testSlowScript)
     return true;
 }
 
 bool
 test(const char *bytes)
 {
     jsval v;
 
-    JS_SetOptions(cx, JS_GetOptions(cx) & ~(JSOPTION_METHODJIT | JSOPTION_METHODJIT_ALWAYS)); 
+    JS_SetOptions(cx, JS_GetOptions(cx) & ~(JSOPTION_METHODJIT | JSOPTION_METHODJIT_ALWAYS));
     sRemain = 0;
     CHECK(!evaluate(bytes, __FILE__, __LINE__, &v));
     CHECK(!JS_IsExceptionPending(cx));
 
     sRemain = 1000;
     CHECK(!evaluate(bytes, __FILE__, __LINE__, &v));
     CHECK(!JS_IsExceptionPending(cx));
 
--- a/js/src/jsapi-tests/testVersion.cpp
+++ b/js/src/jsapi-tests/testVersion.cpp
@@ -218,27 +218,27 @@ END_FIXTURE_TEST(VersionFixture, testOpt
  * version progression.  This is maintained by the |AutoVersionAPI| class in
  * jsapi.cpp.
  */
 BEGIN_FIXTURE_TEST(VersionFixture, testEntryLosesOverride)
 {
     EXEC("overrideVersion15(); evalScriptVersion16('checkOverride(false); captureVersion()');");
     CHECK_EQUAL(captured, JSVERSION_1_6);
 
-    /* 
+    /*
      * Override gets propagated to default version as non-override when you leave the VM's execute
      * call.
      */
     CHECK_EQUAL(JS_GetVersion(cx), JSVERSION_1_5);
     CHECK(!cx->isVersionOverridden());
     return true;
 }
 END_FIXTURE_TEST(VersionFixture, testEntryLosesOverride)
 
-/* 
+/*
  * EvalScriptVersion does not propagate overrides to its caller, it
  * restores things exactly as they were before the call. This is as opposed to
  * the normal (no Version suffix) API which propagates overrides
  * to the caller.
  */
 BEGIN_FIXTURE_TEST(VersionFixture, testReturnLosesOverride)
 {
     CHECK_EQUAL(JS_GetVersion(cx), JSVERSION_ECMA_5);
--- a/js/src/jsapi-tests/testXDR.cpp
+++ b/js/src/jsapi-tests/testXDR.cpp
@@ -73,37 +73,37 @@ static JSPrincipals testPrincipals[] = {
 BEGIN_TEST(testXDR_principals)
 {
     JSScript *script;
     for (int i = TEST_FIRST; i != TEST_END; ++i) {
         script = createScriptViaXDR(NULL, NULL, i);
         CHECK(script);
         CHECK(!JS_GetScriptPrincipals(script));
         CHECK(!JS_GetScriptOriginPrincipals(script));
-    
+
         script = createScriptViaXDR(NULL, NULL, i);
         CHECK(script);
         CHECK(!JS_GetScriptPrincipals(script));
         CHECK(!JS_GetScriptOriginPrincipals(script));
-        
+
         script = createScriptViaXDR(&testPrincipals[0], NULL, i);
         CHECK(script);
         CHECK(JS_GetScriptPrincipals(script) == &testPrincipals[0]);
         CHECK(JS_GetScriptOriginPrincipals(script) == &testPrincipals[0]);
-        
+
         script = createScriptViaXDR(&testPrincipals[0], &testPrincipals[0], i);
         CHECK(script);
         CHECK(JS_GetScriptPrincipals(script) == &testPrincipals[0]);
         CHECK(JS_GetScriptOriginPrincipals(script) == &testPrincipals[0]);
-        
+
         script = createScriptViaXDR(&testPrincipals[0], &testPrincipals[1], i);
         CHECK(script);
         CHECK(JS_GetScriptPrincipals(script) == &testPrincipals[0]);
         CHECK(JS_GetScriptOriginPrincipals(script) == &testPrincipals[1]);
-        
+
         script = createScriptViaXDR(NULL, &testPrincipals[1], i);
         CHECK(script);
         CHECK(!JS_GetScriptPrincipals(script));
         CHECK(JS_GetScriptOriginPrincipals(script) == &testPrincipals[1]);
     }
 
     return true;
 }
@@ -161,17 +161,17 @@ BEGIN_TEST(testXDR_atline)
 "function nested() { }\n"
 "//@line 200 \"bar\"\n"
 "nested;\n";
 
     JSScript *script = JS_CompileScript(cx, global, src, strlen(src), "internal", 1);
     CHECK(script);
     CHECK(script = FreezeThaw(cx, script));
     CHECK(!strcmp("bar", JS_GetScriptFilename(cx, script)));
-    
+
     JS::Value v;
     JSBool ok = JS_ExecuteScript(cx, global, script, &v);
     CHECK(ok);
     CHECK(v.isObject());
 
     JSObject *funobj = &v.toObject();
     script = JS_GetFunctionScript(cx, JS_GetObjectFunction(funobj));
     CHECK(!strcmp("foo", JS_GetScriptFilename(cx, script)));
--- a/js/src/jsapi.cpp
+++ b/js/src/jsapi.cpp
@@ -4457,17 +4457,17 @@ JS_SetReservedSlot(JSObject *obj, uint32
 }
 
 JS_PUBLIC_API(JSObject *)
 JS_NewArrayObject(JSContext *cx, int length, jsval *vector)
 {
     JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
     AssertNoGC(cx);
     CHECK_REQUEST(cx);
-    
+
     assertSameCompartment(cx, JSValueArray(vector, vector ? (uint32_t)length : 0));
     return NewDenseCopiedArray(cx, (uint32_t)length, vector);
 }
 
 JS_PUBLIC_API(JSBool)
 JS_IsArrayObject(JSContext *cx, JSObject *obj)
 {
     assertSameCompartment(cx, obj);
--- a/js/src/jsapi.h
+++ b/js/src/jsapi.h
@@ -3103,17 +3103,17 @@ JS_free(JSContext *cx, void *p);
 /*
  * A wrapper for js_free(p) that may delay js_free(p) invocation as a
  * performance optimization as specified by the given JSFreeOp instance.
  */
 extern JS_PUBLIC_API(void)
 JS_freeop(JSFreeOp *fop, void *p);
 
 extern JS_PUBLIC_API(JSFreeOp *)
-JS_GetDefaultFreeOp(JSRuntime *rt);    
+JS_GetDefaultFreeOp(JSRuntime *rt);
 
 extern JS_PUBLIC_API(void)
 JS_updateMallocCounter(JSContext *cx, size_t nbytes);
 
 extern JS_PUBLIC_API(char *)
 JS_strdup(JSContext *cx, const char *s);
 
 extern JS_PUBLIC_API(JSBool)
--- a/js/src/jsarray.cpp
+++ b/js/src/jsarray.cpp
@@ -170,17 +170,17 @@ js_GetLengthProperty(JSContext *cx, JSOb
     if (!obj->getProperty(cx, cx->runtime->atomState.lengthAtom, value.address()))
         return false;
 
     if (value.reference().isInt32()) {
         *lengthp = uint32_t(value.reference().toInt32()); /* uint32_t cast does ToUint32_t */
         return true;
     }
 
-    
+
     return ToUint32(cx, value, (uint32_t *)lengthp);
 }
 
 namespace js {
 
 /*
  * Determine if the id represents an array index or an XML property index.
  *
@@ -238,17 +238,17 @@ StringIsArrayIndex(JSLinearString *str, 
 }
 
 }
 
 static JSBool
 BigIndexToId(JSContext *cx, JSObject *obj, uint32_t index, JSBool createAtom,
              jsid *idp)
 {
-    
+
     JS_ASSERT(index > JSID_INT_MAX);
 
     jschar buf[10];
     jschar *start = ArrayEnd(buf);
     do {
         --start;
         *start = (jschar)('0' + index % 10);
         index /= 10;
--- a/js/src/jsatom.cpp
+++ b/js/src/jsatom.cpp
@@ -591,17 +591,17 @@ js::XDRAtom(XDRState<mode> *xdr, JSAtom 
 #if IS_LITTLE_ENDIAN
     /* Directly access the little endian chars in the XDR buffer. */
     const jschar *chars = reinterpret_cast<const jschar *>(xdr->buf.read(nchars * sizeof(jschar)));
     atom = js_AtomizeChars(cx, chars, nchars);
 #else
     /*
      * We must copy chars to a temporary buffer to convert between little and
      * big endian data.
-     */ 
+     */
     jschar *chars;
     jschar stackChars[256];
     if (nchars <= ArrayLength(stackChars)) {
         chars = stackChars;
     } else {
         /*
          * This is very uncommon. Don't use the tempLifoAlloc arena for this as
          * most allocations here will be bigger than tempLifoAlloc's default
--- a/js/src/jsatom.h
+++ b/js/src/jsatom.h
@@ -243,17 +243,17 @@ struct AtomHasher
 };
 
 typedef HashSet<AtomStateEntry, AtomHasher, SystemAllocPolicy> AtomSet;
 
 /*
  * On encodings:
  *
  * - Some string functions have an optional FlationCoding argument that allow
- *   the caller to force CESU-8 encoding handling. 
+ *   the caller to force CESU-8 encoding handling.
  * - Functions that don't take a FlationCoding base their NormalEncoding
  *   behavior on the js_CStringsAreUTF8 value. NormalEncoding is either raw
  *   (simple zero-extension) or UTF-8 depending on js_CStringsAreUTF8.
  * - Functions that explicitly state their encoding do not use the
  *   js_CStringsAreUTF8 value.
  *
  * CESU-8 (Compatibility Encoding Scheme for UTF-16: 8-bit) is a variant of
  * UTF-8 that allows us to store any wide character string as a narrow
--- a/js/src/jsatom.tbl
+++ b/js/src/jsatom.tbl
@@ -13,29 +13,29 @@
  *     atom itself. Usually accessed as cx->runtime->atomState.<id>Atom.
  *
  *   - const char js_<id>_str[]: a global within SpiderMonkey, holding the
  *     atom's name. Some macros skip this, because it's already defined
  *     elsewhere.
  *
  * DEFINE_ATOM(id, name)
  *   Define an atom whose JavaScript string's value is |name|.
- * 
+ *
  * DEFINE_PROTOTYPE_ATOM(id)
  *   Define an atom whose name is the same as one of those defined in
  *   jsproto.tbl. The code that processes that has already declared and
  *   defined the js_<id>_str global, so this defines only the JSAtomState
  *   member.
  *
  * DEFINE_KEYWORD_ATOM(id)
  *   Define an atom whose name is the same as one of those defined in
  *   jskeyword.tbl. The code that processes that has already declared and
  *   defined the js_<id>_str global, so this defines only the JSAtomState
  *   member.
- */ 
+ */
 
 
 
 DEFINE_ATOM(anonymous, "anonymous")
 DEFINE_ATOM(apply, "apply")
 DEFINE_ATOM(arguments, "arguments")
 DEFINE_ATOM(arity, "arity")
 DEFINE_ATOM(BYTES_PER_ELEMENT, "BYTES_PER_ELEMENT")
--- a/js/src/jsatominlines.h
+++ b/js/src/jsatominlines.h
@@ -159,17 +159,17 @@ IdToString(JSContext *cx, jsid id)
 {
     if (JSID_IS_STRING(id))
         return JSID_TO_ATOM(id);
 
     JSString *str;
      if (JS_LIKELY(JSID_IS_INT(id)))
         str = js_IntToString(cx, JSID_TO_INT(id));
     else
-        str = ToStringSlow(cx, IdToValue(id));    
+        str = ToStringSlow(cx, IdToValue(id));
 
     if (!str)
         return NULL;
     return str->ensureFlat(cx);
 }
 
 inline
 AtomHasher::Lookup::Lookup(const JSAtom *atom)
--- a/js/src/jscntxt.cpp
+++ b/js/src/jscntxt.cpp
@@ -106,19 +106,19 @@ void CompartmentCallback(JSRuntime *rt, 
     CallbackData *data = (CallbackData *) vdata;
     data->n += data->mallocSizeOf(compartment);
 }
 
 void
 JSRuntime::sizeOfIncludingThis(JSMallocSizeOfFun mallocSizeOf, RuntimeSizes *runtime)
 {
     runtime->object = mallocSizeOf(this);
-    
+
     runtime->atomsTable = atomState.atoms.sizeOfExcludingThis(mallocSizeOf);
-    
+
     runtime->contexts = 0;
     for (ContextIter acx(this); !acx.done(); acx.next())
         runtime->contexts += acx->sizeOfIncludingThis(mallocSizeOf);
 
     runtime->dtoa = mallocSizeOf(dtoaState);
 
     runtime->temporary = tempLifoAlloc.sizeOfExcludingThis(mallocSizeOf);
 
@@ -143,18 +143,18 @@ JSRuntime::sizeOfIncludingThis(JSMallocS
     JS_IterateCompartments(this, &data, CompartmentCallback);
     runtime->compartmentObjects = data.n;
 }
 
 size_t
 JSRuntime::sizeOfExplicitNonHeap()
 {
     if (!execAlloc_)
-        return 0; 
-    
+        return 0;
+
     size_t mjitCode, regexpCode, unusedCodeMemory;
     execAlloc_->sizeOfCode(&mjitCode, &regexpCode, &unusedCodeMemory);
     return mjitCode + regexpCode + unusedCodeMemory + stackSpace.sizeOfCommitted();
 }
 
 void
 JSRuntime::triggerOperationCallback()
 {
--- a/js/src/jscntxtinlines.h
+++ b/js/src/jscntxtinlines.h
@@ -322,17 +322,17 @@ class CompartmentChecker
         for (Value *p = args.base(); p != args.end(); ++p)
             check(*p);
     }
 
     void check(jsid id) {
         if (JSID_IS_OBJECT(id))
             check(JSID_TO_OBJECT(id));
     }
-    
+
     void check(JSIdArray *ida) {
         if (ida) {
             for (int i = 0; i < ida->length; i++) {
                 if (JSID_IS_OBJECT(ida->vector[i]))
                     check(ida->vector[i]);
             }
         }
     }
--- a/js/src/jscompartment.cpp
+++ b/js/src/jscompartment.cpp
@@ -626,17 +626,17 @@ JSCompartment::setDebugModeFromC(JSConte
     }
     return true;
 }
 
 void
 JSCompartment::updateForDebugMode(FreeOp *fop, AutoDebugModeGC &dmgc)
 {
     for (ContextIter acx(rt); !acx.done(); acx.next()) {
-        if (acx->compartment == this) 
+        if (acx->compartment == this)
             acx->updateJITEnabled();
     }
 
 #ifdef JS_METHODJIT
     bool enabled = debugMode();
 
     if (enabled)
         JS_ASSERT(!hasScriptsOnStack());
--- a/js/src/jsdate.cpp
+++ b/js/src/jsdate.cpp
@@ -2792,19 +2792,19 @@ js_DateGetMinutes(JSContext *cx, JSObjec
         return 0;
 
     return (int) MinFromTime(localtime);
 }
 
 JS_FRIEND_API(int)
 js_DateGetSeconds(JSContext *cx, JSObject* obj)
 {
-    if (!obj->isDate()) 
+    if (!obj->isDate())
         return 0;
-    
+
     double utctime = obj->getDateUTCTime().toNumber();
     if (MOZ_DOUBLE_IS_NaN(utctime))
         return 0;
     return (int) SecFromTime(utctime);
 }
 
 JS_FRIEND_API(double)
 js_DateGetMsecSinceEpoch(JSContext *cx, JSObject *obj)
--- a/js/src/jsdbgapi.cpp
+++ b/js/src/jsdbgapi.cpp
@@ -1399,17 +1399,17 @@ DumpCallgrind(JSContext *cx, unsigned ar
     }
 
     RequiredStringArg outFile(cx, argc, vp, 0, "dumpCallgrind");
     if (!outFile)
         return JS_FALSE;
 
     JS_SET_RVAL(cx, vp, BOOLEAN_TO_JSVAL(js_DumpCallgrind(outFile.mBytes)));
     return JS_TRUE;
-}    
+}
 #endif
 
 #ifdef MOZ_VTUNE
 static JSBool
 StartVtune(JSContext *cx, unsigned argc, jsval *vp)
 {
     RequiredStringArg profileName(cx, argc, vp, 0, "startVtune");
     if (!profileName)
--- a/js/src/jsdtoa.h
+++ b/js/src/jsdtoa.h
@@ -97,17 +97,17 @@ typedef enum JSDToStrMode {
 #define DTOSTR_STANDARD_BUFFER_SIZE 26
 
 /* Maximum number of characters (including trailing null) that one of the other conversions
  * can produce.  This maximum is reached for TO_FIXED, which can generate up to 21 digits before the decimal point. */
 #define DTOSTR_VARIABLE_BUFFER_SIZE(precision) ((precision)+24 > DTOSTR_STANDARD_BUFFER_SIZE ? (precision)+24 : DTOSTR_STANDARD_BUFFER_SIZE)
 
 /*
  * DO NOT USE THIS FUNCTION IF YOU CAN AVOID IT.  js::NumberToCString() is a
- * better function to use.  
+ * better function to use.
  *
  * Convert dval according to the given mode and return a pointer to the
  * resulting ASCII string.  If mode == DTOSTR_STANDARD and precision == 0 it's
  * equivalent to ToString() as specified by ECMA-262-5 section 9.8.1, but it
  * doesn't handle integers specially so should be avoided in that case (that's
  * why js::NumberToCString() is better).
  *
  * The result is held somewhere in buffer, but not necessarily at the
@@ -117,17 +117,17 @@ typedef enum JSDToStrMode {
  * Return NULL if out of memory.
  */
 char *
 js_dtostr(DtoaState *state, char *buffer, size_t bufferSize, JSDToStrMode mode, int precision,
           double dval);
 
 /*
  * DO NOT USE THIS FUNCTION IF YOU CAN AVOID IT.  js::NumberToCString() is a
- * better function to use.  
+ * better function to use.
  *
  * Convert d to a string in the given base.  The integral part of d will be
  * printed exactly in that base, regardless of how large it is, because there
  * is no exponential notation for non-base-ten numbers.  The fractional part
  * will be rounded to as few digits as possible while still preserving the
  * round-trip property (analogous to that of printing decimal numbers).  In
  * other words, if one were to read the resulting string in via a hypothetical
  * base-number-reading routine that rounds to the nearest IEEE double (and to
--- a/js/src/jsexn.cpp
+++ b/js/src/jsexn.cpp
@@ -505,113 +505,46 @@ js_ErrorFromException(JSContext *cx, jsv
     if (!priv)
         return NULL;
     return priv->errorReport;
 }
 
 static JSString *
 StackTraceToString(JSContext *cx, JSExnPrivate *priv)
 {
-    jschar *stackbuf;
-    size_t stacklen, stackmax;
-    JSStackTraceElem *elem, *endElem;
-    JSString *str;
-    const char *cp;
-    char ulnbuf[11];
-
-    /* After this point, failing control flow must goto bad. */
-    stackbuf = NULL;
-    stacklen = stackmax = 0;
-
-/* Limit the stackbuf length to a reasonable value to avoid overflow checks. */
-#define STACK_LENGTH_LIMIT JS_BIT(20)
+    StringBuffer sb(cx);
 
-#define APPEND_CHAR_TO_STACK(c)                                               \
-    JS_BEGIN_MACRO                                                            \
-        if (stacklen == stackmax) {                                           \
-            void *ptr_;                                                       \
-            if (stackmax >= STACK_LENGTH_LIMIT)                               \
-                goto done;                                                    \
-            stackmax = stackmax ? 2 * stackmax : 64;                          \
-            ptr_ = cx->realloc_(stackbuf, (stackmax+1) * sizeof(jschar));      \
-            if (!ptr_)                                                        \
-                goto bad;                                                     \
-            stackbuf = (jschar *) ptr_;                                       \
-        }                                                                     \
-        stackbuf[stacklen++] = (c);                                           \
-    JS_END_MACRO
+    JSStackTraceElem *element = priv->stackElems, *end = element + priv->stackDepth;
+    for (; element < end; element++) {
+        /* Try to reserve required space upfront, so we don't fail inbetween. */
+        size_t length = ((element->funName ? element->funName->length() : 0) +
+                         (element->filename ? strlen(element->filename) * 2 : 0) +
+                         13); /* "@" + ":" + "4294967295" + "\n" */
+
+        if (!sb.reserve(length) || sb.length() > JS_BIT(20))
+            break; /* Return as much as we got. */
 
-#define APPEND_STRING_TO_STACK(str)                                           \
-    JS_BEGIN_MACRO                                                            \
-        JSString *str_ = str;                                                 \
-        size_t length_ = str_->length();                                      \
-        const jschar *chars_ = str_->getChars(cx);                            \
-        if (!chars_)                                                          \
-            goto bad;                                                         \
-                                                                              \
-        if (length_ > stackmax - stacklen) {                                  \
-            void *ptr_;                                                       \
-            if (stackmax >= STACK_LENGTH_LIMIT ||                             \
-                length_ >= STACK_LENGTH_LIMIT - stacklen) {                   \
-                goto done;                                                    \
-            }                                                                 \
-            stackmax = RoundUpPow2(stacklen + length_);                       \
-            ptr_ = cx->realloc_(stackbuf, (stackmax+1) * sizeof(jschar));     \
-            if (!ptr_)                                                        \
-                goto bad;                                                     \
-            stackbuf = (jschar *) ptr_;                                       \
-        }                                                                     \
-        js_strncpy(stackbuf + stacklen, chars_, length_);                     \
-        stacklen += length_;                                                  \
-    JS_END_MACRO
-
-    elem = priv->stackElems;
-    for (endElem = elem + priv->stackDepth; elem != endElem; elem++) {
-        if (elem->funName)
-            APPEND_STRING_TO_STACK(elem->funName);
-        APPEND_CHAR_TO_STACK('@');
-        if (elem->filename) {
-            for (cp = elem->filename; *cp; cp++)
-                APPEND_CHAR_TO_STACK(*cp);
+        if (element->funName) {
+            if (!sb.append(element->funName))
+                return NULL;
         }
-        APPEND_CHAR_TO_STACK(':');
-        JS_snprintf(ulnbuf, sizeof ulnbuf, "%u", elem->ulineno);
-        for (cp = ulnbuf; *cp; cp++)
-            APPEND_CHAR_TO_STACK(*cp);
-        APPEND_CHAR_TO_STACK('\n');
-    }
-#undef APPEND_CHAR_TO_STACK
-#undef APPEND_STRING_TO_STACK
-#undef STACK_LENGTH_LIMIT
-
-  done:
-    if (stacklen == 0) {
-        JS_ASSERT(!stackbuf);
-        return cx->runtime->emptyString;
-    }
-    if (stacklen < stackmax) {
-        /*
-         * Realloc can fail when shrinking on some FreeBSD versions, so
-         * don't use JS_realloc here; simply let the oversized allocation
-         * be owned by the string in that rare case.
-         */
-        void *shrunk = cx->realloc_(stackbuf, (stacklen+1) * sizeof(jschar));
-        if (shrunk)
-            stackbuf = (jschar *) shrunk;
+        if (!sb.append('@'))
+            return NULL;
+        if (element->filename) {
+            if (!sb.appendInflated(element->filename, strlen(element->filename)))
+                return NULL;
+        }
+        if (!sb.append(':') || !NumberValueToStringBuffer(cx, NumberValue(element->ulineno), sb) || 
+            !sb.append('\n'))
+        {
+            return NULL;
+        }
     }
 
-    stackbuf[stacklen] = 0;
-    str = js_NewString(cx, stackbuf, stacklen);
-    if (str)
-        return str;
-
-  bad:
-    if (stackbuf)
-        cx->free_(stackbuf);
-    return NULL;
+    return sb.finishString();
 }
 
 /* XXXbe Consolidate the ugly truth that we don't treat filename as UTF-8
          with these two functions. */
 static JSString *
 FilenameToString(JSContext *cx, const char *filename)
 {
     return JS_NewStringCopyZ(cx, filename);
--- a/js/src/jsfriendapi.cpp
+++ b/js/src/jsfriendapi.cpp
@@ -72,17 +72,17 @@ JS_FRIEND_API(JSObject *)
 JS_FindCompilationScope(JSContext *cx, JSObject *obj)
 {
     /*
      * We unwrap wrappers here. This is a little weird, but it's what's being
      * asked of us.
      */
     if (obj->isWrapper())
         obj = UnwrapObject(obj);
-    
+
     /*
      * Innerize the target_obj so that we compile in the correct (inner)
      * scope.
      */
     if (JSObjectOp op = obj->getClass()->ext.innerObject)
         obj = op(cx, obj);
     return obj;
 }
--- a/js/src/jsfun.cpp
+++ b/js/src/jsfun.cpp
@@ -221,17 +221,17 @@ fun_enumerate(JSContext *cx, JSObject *o
         id = NameToId(cx->runtime->atomState.classPrototypeAtom);
         if (!obj->hasProperty(cx, id, &found, JSRESOLVE_QUALIFIED))
             return false;
     }
 
     id = NameToId(cx->runtime->atomState.lengthAtom);
     if (!obj->hasProperty(cx, id, &found, JSRESOLVE_QUALIFIED))
         return false;
-        
+
     id = NameToId(cx->runtime->atomState.nameAtom);
     if (!obj->hasProperty(cx, id, &found, JSRESOLVE_QUALIFIED))
         return false;
 
     for (unsigned i = 0; i < ArrayLength(poisonPillProps); i++) {
         const uint16_t offset = poisonPillProps[i];
         id = NameToId(OFFSET_TO_NAME(cx->runtime, offset));
         if (!obj->hasProperty(cx, id, &found, JSRESOLVE_QUALIFIED))
@@ -323,17 +323,17 @@ fun_resolve(JSContext *cx, JSObject *obj
         JSID_IS_ATOM(id, cx->runtime->atomState.nameAtom)) {
         JS_ASSERT(!IsInternalFunctionObject(obj));
 
         Value v;
         if (JSID_IS_ATOM(id, cx->runtime->atomState.lengthAtom))
             v.setInt32(fun->nargs);
         else
             v.setString(fun->atom ? fun->atom : cx->runtime->emptyString);
-        
+
         if (!DefineNativeProperty(cx, fun, id, v, JS_PropertyStub, JS_StrictPropertyStub,
                                   JSPROP_PERMANENT | JSPROP_READONLY, 0, 0)) {
             return false;
         }
         *objp = fun;
         return true;
     }
 
--- a/js/src/jsfun.h
+++ b/js/src/jsfun.h
@@ -205,17 +205,17 @@ struct JSFunction : public JSObject
 
   public:
     /* Accessors for data stored in extended functions. */
     inline void initializeExtended();
     inline void setExtendedSlot(size_t which, const js::Value &val);
     inline const js::Value &getExtendedSlot(size_t which) const;
 
   private:
-    /* 
+    /*
      * These member functions are inherited from JSObject, but should never be applied to
      * a value statically known to be a JSFunction.
      */
     inline JSFunction *toFunction() MOZ_DELETE;
     inline const JSFunction *toFunction() const MOZ_DELETE;
 };
 
 inline JSFunction *
--- a/js/src/jsgc.cpp
+++ b/js/src/jsgc.cpp
@@ -3629,17 +3629,17 @@ GCCycle(JSRuntime *rt, bool incremental,
         if (rt->gcIncrementalState == NO_INCREMENTAL) {
             for (CompartmentsIter c(rt); !c.done(); c.next())
                 JS_ASSERT(!c->needsBarrier());
         }
 #endif
         if (shouldSweep)
             SweepPhase(rt, gckind, &startBackgroundSweep);
     }
-        
+
 #ifdef JS_THREADSAFE
     if (startBackgroundSweep)
         rt->gcHelperThread.startBackgroundSweep(gckind == GC_SHRINK);
 #endif
 }
 
 #ifdef JS_GC_ZEAL
 static bool
--- a/js/src/jsinfer.cpp
+++ b/js/src/jsinfer.cpp
@@ -345,17 +345,17 @@ types::TypeFailure(JSContext *cx, const 
 
     JS_snprintf(msgbuf, sizeof(msgbuf), "[infer failure] %s", errbuf);
 
     /* Dump type state, even if INFERFLAGS is unset. */
     cx->compartment->types.print(cx, true);
 
     /* Always active, even in release builds */
     MOZ_Assert(msgbuf, __FILE__, __LINE__);
-    
+
     *((volatile int *)NULL) = 0;  /* Should never be reached */
 }
 
 /////////////////////////////////////////////////////////////////////
 // TypeSet
 /////////////////////////////////////////////////////////////////////
 
 TypeSet *
@@ -398,17 +398,17 @@ TypeSet::add(JSContext *cx, TypeConstrai
 
     if (!callExisting)
         return;
 
     /* If any type is possible, there's no need to worry about specifics. */
     if (flags & TYPE_FLAG_UNKNOWN) {
         cx->compartment->types.addPending(cx, constraint, this, Type::UnknownType());
     } else {
-        /* Enqueue type set members stored as bits. */ 
+        /* Enqueue type set members stored as bits. */
         for (TypeFlags flag = 1; flag < TYPE_FLAG_ANYOBJECT; flag <<= 1) {
             if (flags & flag) {
                 Type type = Type::PrimitiveType(TypeFlagPrimitive(flag));
                 cx->compartment->types.addPending(cx, constraint, this, type);
             }
         }
 
         /* If any object is possible, skip specifics. */
@@ -2264,17 +2264,17 @@ TypeCompartment::markSetsUnknown(JSConte
 
     AutoEnterTypeInference enter(cx);
 
     /*
      * Mark both persistent and transient type sets which contain obj as having
      * a generic object type. It is not sufficient to mark just the persistent
      * sets, as analysis of individual opcodes can pull type objects from
      * static information (like initializer objects at various offsets).
-     * 
+     *
      * We make a list of properties to update and fix them afterwards, as adding
      * types can't be done while iterating over cells as it can potentially make
      * new type objects as well or trigger GC.
      */
     Vector<TypeSet *> pending(cx);
     for (gc::CellIter i(cx->compartment, gc::FINALIZE_TYPE_OBJECT); !i.done(); i.next()) {
         TypeObject *object = i.get<TypeObject>();
 
@@ -5426,17 +5426,17 @@ TypeScript::CheckBytecode(JSContext *cx,
         TypeSet *types = analysis->pushedTypes(pc, i);
         if (IgnorePushed(pc, i))
             continue;
 
         Type type = GetValueType(cx, val);
 
         if (!types->hasType(type)) {
             /* Display fine-grained debug information first */
-            fprintf(stderr, "Missing type at #%u:%05u pushed %u: %s\n", 
+            fprintf(stderr, "Missing type at #%u:%05u pushed %u: %s\n",
                     script->id(), unsigned(pc - script->code), i, TypeString(type));
             TypeFailure(cx, "Missing type pushed %u: %s", i, TypeString(type));
         }
     }
 }
 
 #endif
 
--- a/js/src/jsinterp.cpp
+++ b/js/src/jsinterp.cpp
@@ -990,24 +990,24 @@ class GenericInterruptEnabler : public I
     GenericInterruptEnabler(T *variable, T value) : variable(variable), value(value) { }
     void enableInterrupts() const { *variable = value; }
 
   private:
     T *variable;
     T value;
 };
 
-inline InterpreterFrames::InterpreterFrames(JSContext *cx, FrameRegs *regs, 
+inline InterpreterFrames::InterpreterFrames(JSContext *cx, FrameRegs *regs,
                                             const InterruptEnablerBase &enabler)
   : context(cx), regs(regs), enabler(enabler)
 {
     older = cx->runtime->interpreterFrames;
     cx->runtime->interpreterFrames = this;
 }
- 
+
 inline InterpreterFrames::~InterpreterFrames()
 {
     context->runtime->interpreterFrames = older;
 }
 
 #if defined(DEBUG) && !defined(JS_THREADSAFE) && !defined(JSGC_ROOT_ANALYSIS)
 void
 js::AssertValidPropertyCacheHit(JSContext *cx,
@@ -1686,17 +1686,17 @@ BEGIN_CASE(JSOP_STOP)
     interpReturnOK = true;
     if (entryFrame != regs.fp())
   inline_return:
     {
         AssertValidFunctionScopeChainAtExit(regs.fp());
 
         if (cx->compartment->debugMode())
             interpReturnOK = ScriptDebugEpilogue(cx, regs.fp(), interpReturnOK);
- 
+
         interpReturnOK = ScriptEpilogue(cx, regs.fp(), interpReturnOK);
 
         /* The JIT inlines ScriptEpilogue. */
 #ifdef JS_METHODJIT
   jit_return:
 #endif
 
         /* The results of lowered call/apply frames need to be shifted. */
--- a/js/src/jsinterp.h
+++ b/js/src/jsinterp.h
@@ -79,34 +79,34 @@ ScriptEpilogueOrGeneratorYield(JSContext
 /* Implemented in jsdbgapi: */
 
 /*
  * Announce to the debugger that the thread has entered a new JavaScript frame,
  * |fp|. Call whatever hooks have been registered to observe new frames, and
  * return a JSTrapStatus code indication how execution should proceed:
  *
  * - JSTRAP_CONTINUE: Continue execution normally.
- * 
+ *
  * - JSTRAP_THROW: Throw an exception. ScriptDebugPrologue has set |cx|'s
  *   pending exception to the value to be thrown.
  *
  * - JSTRAP_ERROR: Terminate execution (as is done when a script is terminated
  *   for running too long). ScriptDebugPrologue has cleared |cx|'s pending
  *   exception.
  *
  * - JSTRAP_RETURN: Return from the new frame immediately. ScriptDebugPrologue
  *   has set |cx->fp()|'s return value appropriately.
  */
 extern JSTrapStatus
 ScriptDebugPrologue(JSContext *cx, StackFrame *fp);
 
 /*
  * Announce to the debugger that the thread has exited a JavaScript frame, |fp|.
  * If |ok| is true, the frame is returning normally; if |ok| is false, the frame
- * is throwing an exception or terminating. 
+ * is throwing an exception or terminating.
  *
  * Call whatever hooks have been registered to observe frame exits. Change cx's
  * current exception and |fp|'s return value to reflect the changes in behavior
  * the hooks request, if any. Return the new error/success value.
  *
  * This function may be called twice for the same outgoing frame; only the
  * first call has any effect. (Permitting double calls simplifies some
  * cases where an onPop handler's resumption value changes a return to a
--- a/js/src/jsinterpinlines.h
+++ b/js/src/jsinterpinlines.h
@@ -126,17 +126,17 @@ ComputeThis(JSContext *cx, StackFrame *f
     return BoxNonStrictThis(cx, fp->callReceiver());
 }
 
 /*
  * Return an object on which we should look for the properties of |value|.
  * This helps us implement the custom [[Get]] method that ES5's GetValue
  * algorithm uses for primitive values, without actually constructing the
  * temporary object that the specification does.
- * 
+ *
  * For objects, return the object itself. For string, boolean, and number
  * primitive values, return the appropriate constructor's prototype. For
  * undefined and null, throw an error and return NULL, attributing the
  * problem to the value at |spindex| on the stack.
  */
 JS_ALWAYS_INLINE JSObject *
 ValuePropertyBearer(JSContext *cx, StackFrame *fp, const Value &v, int spindex)
 {
--- a/js/src/jslibmath.h
+++ b/js/src/jslibmath.h
@@ -89,21 +89,21 @@ inline double
 NumberDiv(double a, double b)
 {
     if (b == 0) {
         if (a == 0 || MOZ_DOUBLE_IS_NaN(a)
 #ifdef XP_WIN
             || MOZ_DOUBLE_IS_NaN(b) /* XXX MSVC miscompiles such that (NaN == 0) */
 #endif
         )
-            return js_NaN;    
+            return js_NaN;
 
         if (MOZ_DOUBLE_IS_NEGATIVE(a) != MOZ_DOUBLE_IS_NEGATIVE(b))
             return js_NegativeInfinity;
-        return js_PositiveInfinity; 
+        return js_PositiveInfinity;
     }
 
     return a / b;
 }
 
 }
 
 #endif /* _LIBMATH_H */
--- a/js/src/jsmath.cpp
+++ b/js/src/jsmath.cpp
@@ -451,17 +451,17 @@ powi(double x, int y)
         if ((n & 1) != 0) p *= m;
         n >>= 1;
         if (n == 0) {
             if (y < 0) {
                 // Unfortunately, we have to be careful when p has reached
                 // infinity in the computation, because sometimes the higher
                 // internal precision in the pow() implementation would have
                 // given us a finite p. This happens very rarely.
-                
+
                 double result = 1.0 / p;
                 return (result == 0 && MOZ_DOUBLE_IS_INFINITE(p))
                        ? pow(x, static_cast<double>(y))  // Avoid pow(double, int).
                        : result;
             }
 
             return p;
         }
--- a/js/src/jsnativestack.cpp
+++ b/js/src/jsnativestack.cpp
@@ -154,17 +154,17 @@ GetNativeStackBaseImpl()
      * other POSIX systems may have different np alternatives
      */
     pthread_getattr_np(thread, &sattr);
 #  endif
 
     void *stackBase = 0;
     size_t stackSize = 0;
 #  ifdef DEBUG
-    int rc = 
+    int rc =
 #  endif
 # if defined(__OpenBSD__)
         pthread_stackseg_np(pthread_self(), &ss);
     stackBase = (void*)((size_t) ss.ss_sp - ss.ss_size);
     stackSize = ss.ss_size;
 # else
         pthread_attr_getstack(&sattr, &stackBase, &stackSize);
 # endif
--- a/js/src/jsnum.cpp
+++ b/js/src/jsnum.cpp
@@ -379,30 +379,30 @@ js::num_parseInt(JSContext *cx, unsigned
     CallArgs args = CallArgsFromVp(argc, vp);
 
     /* Fast paths and exceptional cases. */
     if (args.length() == 0) {
         args.rval().setDouble(js_NaN);
         return true;
     }
 
-    if (args.length() == 1 || 
+    if (args.length() == 1 ||
         (args[1].isInt32() && (args[1].toInt32() == 0 || args[1].toInt32() == 10))) {
         if (args[0].isInt32()) {
             args.rval() = args[0];
             return true;
         }
         /*
          * Step 1 is |inputString = ToString(string)|. When string >=
          * 1e21, ToString(string) is in the form "NeM". 'e' marks the end of
          * the word, which would mean the result of parseInt(string) should be |N|.
          *
          * To preserve this behaviour, we can't use the fast-path when string >
          * 1e21, or else the result would be |NeM|.
-         * 
+         *
          * The same goes for values smaller than 1.0e-6, because the string would be in
          * the form of "Ne-M".
          */
         if (args[0].isDouble()) {
             double d = args[0].toDouble();
             if (1.0e-6 < d && d < 1.0e21) {
                 args.rval().setNumber(floor(d));
                 return true;
--- a/js/src/jsobj.cpp
+++ b/js/src/jsobj.cpp
@@ -630,17 +630,17 @@ namespace js {
 JSString *
 obj_toStringHelper(JSContext *cx, JSObject *obj)
 {
     if (obj->isProxy())
         return Proxy::obj_toString(cx, obj);
 
     StringBuffer sb(cx);
     const char *className = obj->getClass()->name;
-    if (!sb.append("[object ") || !sb.appendInflated(className, strlen(className)) || 
+    if (!sb.append("[object ") || !sb.appendInflated(className, strlen(className)) ||
         !sb.append("]"))
     {
         return NULL;
     }
     return sb.finishString();
 }
 
 JSObject *
--- a/js/src/jsopcode.cpp
+++ b/js/src/jsopcode.cpp
@@ -709,17 +709,17 @@ js_Disassemble1(JSContext *cx, JSScript 
 }
 
 #endif /* DEBUG */
 
 /************************************************************************/
 
 const size_t Sprinter::DefaultSize = 64;
 
-bool 
+bool
 Sprinter::realloc_(size_t newSize)
 {
     JS_ASSERT(newSize > (size_t) offset);
     char *newBuf = (char *) context->realloc_(base, newSize);
     if (!newBuf)
         return false;
     base = newBuf;
     size = newSize;
@@ -4828,17 +4828,17 @@ Decompile(SprintStack *ss, jsbytecode *p
                     /*
                      * Always parenthesize expression closures. We can't force
                      * saveop to a low-precedence op to arrange for auto-magic
                      * parenthesization without confusing getter/setter code
                      * that checks for JSOP_LAMBDA.
                      */
                     bool grouped = !(fun->flags & JSFUN_EXPR_CLOSURE);
                     bool strict = jp->script->strictModeCode;
-                    str = js_DecompileToString(cx, "lambda", fun, 0, 
+                    str = js_DecompileToString(cx, "lambda", fun, 0,
                                                false, grouped, strict,
                                                js_DecompileFunction);
                     if (!str)
                         return NULL;
                 }
               sprint_string:
                 todo = ss->sprinter.putString(str);
                 break;
@@ -5656,17 +5656,17 @@ js_DecompileValueGenerator(JSContext *cx
 
     fp = js_GetTopStackFrame(cx, FRAME_EXPAND_ALL);
     script = fp->script();
     pc = cx->regs().pc;
     JS_ASSERT(script->code <= pc && pc < script->code + script->length);
 
     if (pc < script->main())
         goto do_fallback;
-    
+
     if (spindex != JSDVG_IGNORE_STACK) {
         jsbytecode **pcstack;
 
         /*
          * Prepare computing pcstack containing pointers to opcodes that
          * populated interpreter's stack with its current content.
          */
         pcstack = (jsbytecode **)
--- a/js/src/jspropertycache.h
+++ b/js/src/jspropertycache.h
@@ -167,17 +167,17 @@ class PropertyCache
 # define PCMETER(x)     x
 #else
 # define PCMETER(x)     ((void)0)
 #endif
 
     PropertyCache() {
         PodZero(this);
     }
-    
+
   private:
     static inline uintptr_t
     hash(jsbytecode *pc, const Shape *kshape)
     {
         return (((uintptr_t(pc) >> SIZE_LOG2) ^ uintptr_t(pc) ^ ((uintptr_t)kshape >> 3)) & MASK);
     }
 
     static inline bool matchShape(JSContext *cx, JSObject *obj, uint32_t shape);
--- a/js/src/jspropertytree.h
+++ b/js/src/jspropertytree.h
@@ -101,25 +101,25 @@ class PropertyTree
 {
     friend struct ::JSFunction;
 
     JSCompartment *compartment;
 
     bool insertChild(JSContext *cx, js::Shape *parent, js::Shape *child);
 
     PropertyTree();
-    
+
   public:
     enum { MAX_HEIGHT = 128 };
 
     PropertyTree(JSCompartment *comp)
         : compartment(comp)
     {
     }
-    
+
     js::Shape *newShape(JSContext *cx);
     js::Shape *getChild(JSContext *cx, Shape *parent, uint32_t nfixed, const StackShape &child);
 
 #ifdef DEBUG
     static void dumpShapes(JSRuntime *rt);
     static void meter(JSBasicStats *bs, js::Shape *node);
 #endif
 };
--- a/js/src/jsproxy.cpp
+++ b/js/src/jsproxy.cpp
@@ -168,17 +168,17 @@ BaseProxyHandler::getElementIfPresent(JS
         return false;
 
     if (!*present) {
         Debug_SetValueRangeToCrashOnTouch(vp, 1);
         return true;
     }
 
     return get(cx, proxy, receiver, id, vp);
-}   
+}
 
 bool
 BaseProxyHandler::set(JSContext *cx, JSObject *proxy, JSObject *receiver, jsid id, bool strict,
                   Value *vp)
 {
     JS_ASSERT(OperationInProgress(cx, proxy));
     AutoPropertyDescriptorRooter desc(cx);
     if (!getOwnPropertyDescriptor(cx, proxy, id, true, &desc))
@@ -499,17 +499,17 @@ IndirectProxyHandler::hasInstance(JSCont
     JSBool b;
     if (!JS_HasInstance(cx, GetProxyTargetObject(proxy), *vp, &b))
         return false;
     *bp = !!b;
     return true;
 }
 
 JSType
-IndirectProxyHandler::typeOf(JSContext *cx, JSObject *proxy) 
+IndirectProxyHandler::typeOf(JSContext *cx, JSObject *proxy)
 {
     return TypeOfValue(cx, ObjectValue(*GetProxyTargetObject(proxy)));
 }
 
 bool
 IndirectProxyHandler::objectClassIs(JSObject *proxy, ESClassValue classValue,
                                     JSContext *cx)
 {
@@ -550,17 +550,17 @@ bool
 IndirectProxyHandler::iteratorNext(JSContext *cx, JSObject *proxy, Value *vp)
 {
     if (!js_IteratorMore(cx, RootedVarObject(cx, GetProxyTargetObject(proxy)),
                          vp))
         return false;
     if (vp->toBoolean()) {
         *vp = cx->iterValue;
         cx->iterValue.setUndefined();
-    } else 
+    } else
         vp->setMagic(JS_NO_ITER_VALUE);
     return true;
 }
 
 void
 IndirectProxyHandler::trace(JSTracer *trc, JSObject *proxy)
 {
     MarkSlot(trc, &proxy->getReservedSlotRef(JSSLOT_PROXY_PRIVATE), "targetObject");
@@ -916,17 +916,17 @@ ScriptedProxyHandler::iterate(JSContext 
         return false;
     if (!js_IsCallable(value))
         return BaseProxyHandler::iterate(cx, proxy, flags, vp);
     return Trap(cx, handler, value, 0, NULL, vp) &&
            ReturnedValueMustNotBePrimitive(cx, proxy, ATOM(iterate), *vp);
 }
 
 JSType
-ScriptedProxyHandler::typeOf(JSContext *cx, JSObject *proxy) 
+ScriptedProxyHandler::typeOf(JSContext *cx, JSObject *proxy)
 {
     /*
      * This function is only here to prevent a regression in
      * js1_8_5/extensions/scripted-proxies.js. It will be removed when the
      * direct proxy refactor is complete.
      */
     return IsFunctionProxy(proxy) ? JSTYPE_FUNCTION : JSTYPE_OBJECT;
 }
--- a/js/src/jsreflect.cpp
+++ b/js/src/jsreflect.cpp
@@ -672,17 +672,17 @@ NodeBuilder::newArray(NodeVector &elts, 
 
 bool
 NodeBuilder::newNodeLoc(TokenPos *pos, Value *dst)
 {
     if (!pos) {
         dst->setNull();
         return true;
     }
- 
+
     JSObject *loc, *to;
     Value tv;
 
     if (!newObject(&loc))
         return false;
 
     dst->setObject(*loc);
 
--- a/js/src/jsreops.tbl
+++ b/js/src/jsreops.tbl
@@ -84,17 +84,17 @@ REOP_DEF(REOP_UCFLAT,        "ucflat")
 /* case-independent REOP_UCFLAT */
 REOP_DEF(REOP_UCFLATi,       "ucflati")
 /* character class with index */
 REOP_DEF(REOP_CLASS,         "class")
 /* negated character class with index */
 REOP_DEF(REOP_NCLASS,        "nclass")
 
 /* NCLASS is considered to be the last "simple" op-code */
-    
+
 
 /* alternative subexpressions in kid and next */
 REOP_DEF(REOP_ALT,           "alt")
 /* quantified atom: atom{1,2} */
 REOP_DEF(REOP_QUANT,         "quant")
 /* zero or more occurrences of kid */
 REOP_DEF(REOP_STAR,          "star")
 /* one or more occurrences of kid */
--- a/js/src/jsscope.cpp
+++ b/js/src/jsscope.cpp
@@ -673,17 +673,17 @@ JSObject::putProperty(JSContext *cx, jsi
 
     /* Property exists: search must have returned a valid *spp. */
     JS_ASSERT_IF(spp, !SHAPE_IS_REMOVED(*spp));
 
     RootShape shapeRoot(cx, &shape);
 
     if (!CheckCanChangeAttrs(cx, self, shape, &attrs))
         return NULL;
-    
+
     /*
      * If the caller wants to allocate a slot, but doesn't care which slot,
      * copy the existing shape's slot into slot so we can match shape, if all
      * other members match.
      */
     bool hadSlot = shape->hasSlot();
     uint32_t oldSlot = shape->maybeSlot();
     if (!(attrs & JSPROP_SHARED) && slot == SHAPE_INVALID_SLOT && hadSlot)
@@ -812,17 +812,17 @@ JSObject::changeProperty(JSContext *cx, 
 
     if (getter == JS_PropertyStub)
         getter = NULL;
     if (setter == JS_StrictPropertyStub)
         setter = NULL;
 
     if (!CheckCanChangeAttrs(cx, this, shape, &attrs))
         return NULL;
-    
+
     if (shape->attrs == attrs && shape->getter() == getter && shape->setter() == setter)
         return shape;
 
     /*
      * Let JSObject::putProperty handle this |overwriting| case, including
      * the conservation of shape->slot (if it's valid). We must not call
      * removeProperty because it will free an allocated shape->slot, and
      * putProperty won't re-allocate it.
--- a/js/src/jsscope.h
+++ b/js/src/jsscope.h
@@ -63,57 +63,57 @@
 #pragma warning(disable:4100) /* Silence unreferenced formal parameter warnings */
 #endif
 
 /*
  * In isolation, a Shape represents a property that exists in one or more
  * objects; it has an id, flags, etc. (But it doesn't represent the property's
  * value.)  However, Shapes are always stored in linked linear sequence of
  * Shapes, called "shape lineages". Each shape lineage represents the layout of
- * an entire object. 
- *   
+ * an entire object.
+ *
  * Every JSObject has a pointer, |shape_|, accessible via lastProperty(), to
  * the last Shape in a shape lineage, which identifies the property most
  * recently added to the object.  This pointer permits fast object layout
  * tests. The shape lineage order also dictates the enumeration order for the
  * object; ECMA requires no particular order but this implementation has
  * promised and delivered property definition order.
- *   
+ *
  * Shape lineages occur in two kinds of data structure.
- * 
+ *
  * 1. N-ary property trees. Each path from a non-root node to the root node in
  *    a property tree is a shape lineage. Property trees permit full (or
  *    partial) sharing of Shapes between objects that have fully (or partly)
  *    identical layouts. The root is an EmptyShape whose identity is determined
  *    by the object's class, compartment and prototype. These Shapes are shared
  *    and immutable.
- * 
+ *
  * 2. Dictionary mode lists. Shapes in such lists are said to be "in
  *    dictionary mode", as are objects that point to such Shapes. These Shapes
  *    are unshared, private to a single object, and immutable except for their
  *    links in the dictionary list.
- * 
+ *
  * All shape lineages are bi-directionally linked, via the |parent| and
  * |kids|/|listp| members.
- * 
+ *
  * Shape lineages start out life in the property tree. They can be converted
  * (by copying) to dictionary mode lists in the following circumstances.
- * 
+ *
  * 1. The shape lineage's size reaches MAX_HEIGHT. This reasonable limit avoids
  *    potential worst cases involving shape lineage mutations.
- * 
+ *
  * 2. A property represented by a non-last Shape in a shape lineage is removed
  *    from an object. (In the last Shape case, obj->shape_ can be easily
  *    adjusted to point to obj->shape_->parent.)  We originally tried lazy
  *    forking of the property tree, but this blows up for delete/add
  *    repetitions.
- * 
+ *
  * 3. A property represented by a non-last Shape in a shape lineage has its
  *    attributes modified.
- * 
+ *
  * To find the Shape for a particular property of an object initially requires
  * a linear search. But if the number of searches starting at any particular
  * Shape in the property tree exceeds MAX_LINEAR_SEARCHES and the Shape's
  * lineage has (excluding the EmptyShape) at least MIN_ENTRIES, we create an
  * auxiliary hash table -- the ShapeTable -- that allows faster lookup.
  * Furthermore, a ShapeTable is always created for dictionary mode lists,
  * and it is attached to the last Shape in the lineage. Shape tables for
  * property tree Shapes never change, but shape tables for dictionary mode
@@ -478,17 +478,17 @@ struct Shape : public js::gc::Cell
 
     JS_ENUM_HEADER(SlotInfo, uint32_t)
     {
         /* Number of fixed slots in objects with this shape. */
         FIXED_SLOTS_MAX        = 0x1f,
         FIXED_SLOTS_SHIFT      = 27,
         FIXED_SLOTS_MASK       = uint32_t(FIXED_SLOTS_MAX << FIXED_SLOTS_SHIFT),
 
-        /* 
+        /*
          * numLinearSearches starts at zero and is incremented initially on
          * search() calls. Once numLinearSearches reaches LINEAR_SEARCHES_MAX,
          * the table is created on the next search() call. The table can also
          * be created when hashifying for dictionary mode.
          */
         LINEAR_SEARCHES_MAX    = 0x7,
         LINEAR_SEARCHES_SHIFT  = 24,
         LINEAR_SEARCHES_MASK   = LINEAR_SEARCHES_MAX << LINEAR_SEARCHES_SHIFT,
--- a/js/src/jsscript.cpp
+++ b/js/src/jsscript.cpp
@@ -431,17 +431,17 @@ js::XDRScript(XDRState<mode> *xdr, JSScr
 #if defined(DEBUG) || defined(__GNUC__) /* quell GCC overwarning */
     script = NULL;
     nargs = nvars = Bindings::BINDING_COUNT_LIMIT;
 #endif
     uint32_t argsVars;
     if (mode == XDR_ENCODE) {
         script = *scriptp;
         JS_ASSERT_IF(parentScript, parentScript->compartment() == script->compartment());
-    
+
         nargs = script->bindings.numArgs();
         nvars = script->bindings.numVars();
         argsVars = (nargs << 16) | nvars;
     }
     if (!xdr->codeUint32(&argsVars))
         return false;
     if (mode == XDR_DECODE) {
         nargs = argsVars >> 16;
@@ -1027,35 +1027,35 @@ js::FreeScriptFilenames(JSRuntime *rt)
  * ----------       --------------  --------
  * ConstArray       Consts          consts()
  * ObjectArray      Objects         objects()
  * ObjectArray      Regexps         regexps()
  * TryNoteArray     Try notes       trynotes()
  * ClosedSlotArray  ClosedArgs      closedArgs()
  * ClosedSlotArray  ClosedVars      closedVars()
  *
- * Then are the elements of several arrays.  
+ * Then are the elements of several arrays.
  * - Most of these arrays have headers listed above (if present).  For each of
- *   these, the array pointer and the array length is stored in the header.  
+ *   these, the array pointer and the array length is stored in the header.
  * - The remaining arrays have pointers and lengths that are stored directly in
  *   JSScript.  This is because, unlike the others, they are nearly always
  *   non-zero length and so the optional-header space optimization isn't
  *   worthwhile.
  *
  * Array elements   Pointed to by         Length
  * --------------   -------------         ------
  * Consts           consts()->vector      consts()->length
  * Atoms            atoms                 natoms
  * Objects          objects()->vector     objects()->length
  * Regexps          regexps()->vector     regexps()->length
  * Try notes        trynotes()->vector    trynotes()->length
  * Closed args      closedArgs()->vector  closedArgs()->length
  * Closed vars      closedVars()->vector  closedVars()->length
  * Bytecodes        code                  length
- * Source notes     notes()               numNotes() * sizeof(jssrcnote)  
+ * Source notes     notes()               numNotes() * sizeof(jssrcnote)
  *
  * IMPORTANT: This layout has two key properties.
  * - It ensures that everything has sufficient alignment;  in particular, the
  *   consts() elements need jsval alignment.
  * - It ensures there are no gaps between elements, which saves space and makes
  *   manual layout easy.  In particular, in the second part, arrays with larger
  *   elements precede arrays with smaller elements.
  *
--- a/js/src/jsscript.h
+++ b/js/src/jsscript.h
@@ -415,17 +415,17 @@ struct JSScript : public js::gc::Cell
   public:
     js::Bindings    bindings;   /* names of top-level variables in this script
                                    (and arguments if this is a function script) */
 
     // Word-sized fields.
 
   public:
     jsbytecode      *code;      /* bytecodes and their immediate operands */
-    uint8_t         *data;      /* pointer to variable-length data array (see 
+    uint8_t         *data;      /* pointer to variable-length data array (see
                                    comment above NewScript() for details) */
 
     const char      *filename;  /* source filename or null */
     js::HeapPtrAtom *atoms;     /* maps immediate index to literal struct */
 
     JSPrincipals    *principals;/* principals for this script */
     JSPrincipals    *originPrincipals; /* see jsapi.h 'originPrincipals' comment */
 
--- a/js/src/jsshell.msg
+++ b/js/src/jsshell.msg
@@ -37,22 +37,22 @@
  *
  * ***** END LICENSE BLOCK ***** */
 
 /*
 	Error messages for JSShell. See js.msg for format.
 */
 
 MSG_DEF(JSSMSG_NOT_AN_ERROR,             0, 0, JSEXN_NONE, "<Error #0 is reserved>")
-MSG_DEF(JSSMSG_CANT_OPEN,                1, 2, JSEXN_NONE, "can't open {0}: {1}") 
-MSG_DEF(JSSMSG_TRAP_USAGE,               2, 0, JSEXN_NONE, "usage: trap [fun] [pc] expr") 
-MSG_DEF(JSSMSG_LINE2PC_USAGE,            3, 0, JSEXN_NONE, "usage: line2pc [fun] line") 
-MSG_DEF(JSSMSG_FILE_SCRIPTS_ONLY,        4, 0, JSEXN_NONE, "only works on JS scripts read from files") 
-MSG_DEF(JSSMSG_UNEXPECTED_EOF,           5, 1, JSEXN_NONE, "unexpected EOF in {0}") 
-MSG_DEF(JSSMSG_DOEXP_USAGE,              6, 0, JSEXN_NONE, "usage: doexp obj id") 
-MSG_DEF(JSSMSG_SCRIPTS_ONLY,             7, 0, JSEXN_NONE, "only works on scripts") 
+MSG_DEF(JSSMSG_CANT_OPEN,                1, 2, JSEXN_NONE, "can't open {0}: {1}")
+MSG_DEF(JSSMSG_TRAP_USAGE,               2, 0, JSEXN_NONE, "usage: trap [fun] [pc] expr")
+MSG_DEF(JSSMSG_LINE2PC_USAGE,            3, 0, JSEXN_NONE, "usage: line2pc [fun] line")
+MSG_DEF(JSSMSG_FILE_SCRIPTS_ONLY,        4, 0, JSEXN_NONE, "only works on JS scripts read from files")
+MSG_DEF(JSSMSG_UNEXPECTED_EOF,           5, 1, JSEXN_NONE, "unexpected EOF in {0}")
+MSG_DEF(JSSMSG_DOEXP_USAGE,              6, 0, JSEXN_NONE, "usage: doexp obj id")
+MSG_DEF(JSSMSG_SCRIPTS_ONLY,             7, 0, JSEXN_NONE, "only works on scripts")
 MSG_DEF(JSSMSG_NOT_ENOUGH_ARGS,          8, 1, JSEXN_NONE, "{0}: not enough arguments")
 MSG_DEF(JSSMSG_TOO_MANY_ARGS,            9, 1, JSEXN_NONE, "{0}: too many arguments")
 MSG_DEF(JSSMSG_ASSERT_EQ_FAILED,        10, 2, JSEXN_NONE, "Assertion failed: got {0}, expected {1}")
 MSG_DEF(JSSMSG_ASSERT_EQ_FAILED_MSG,    11, 3, JSEXN_NONE, "Assertion failed: got {0}, expected {1}: {2}")
 MSG_DEF(JSSMSG_INVALID_ARGS,            12, 1, JSEXN_NONE, "{0}: invalid arguments")
 MSG_DEF(JSSMSG_ASSERT_JIT_FAILED,       13, 0, JSEXN_NONE, "unexpected failure to JIT")
 MSG_DEF(JSSMSG_BAD_ALIGNMENT,           14, 0, JSEXN_NONE, "serialized data must be 8-byte-aligned")
--- a/js/src/jsstr.cpp
+++ b/js/src/jsstr.cpp
@@ -3811,22 +3811,22 @@ const jschar js_uriUnescaped_ucstr[] =
 const bool js_isidstart[] = {
 /*       0     1     2     3     4     5     6     7     8     9  */
 /*  0 */ ____, ____, ____, ____, ____, ____, ____, ____, ____, ____,
 /*  1 */ ____, ____, ____, ____, ____, ____, ____, ____, ____, ____,
 /*  2 */ ____, ____, ____, ____, ____, ____, ____, ____, ____, ____,
 /*  3 */ ____, ____, ____, ____, ____, ____, true, ____, ____, ____,
 /*  4 */ ____, ____, ____, ____, ____, ____, ____, ____, ____, ____,
 /*  5 */ ____, ____, ____, ____, ____, ____, ____, ____, ____, ____,
-/*  6 */ ____, ____, ____, ____, ____, true, true, true, true, true, 
-/*  7 */ true, true, true, true, true, true, true, true, true, true, 
-/*  8 */ true, true, true, true, true, true, true, true, true, true, 
-/*  9 */ true, ____, ____, ____, ____, true, ____, true, true, true, 
-/* 10 */ true, true, true, true, true, true, true, true, true, true, 
-/* 11 */ true, true, true, true, true, true, true, true, true, true, 
+/*  6 */ ____, ____, ____, ____, ____, true, true, true, true, true,
+/*  7 */ true, true, true, true, true, true, true, true, true, true,
+/*  8 */ true, true, true, true, true, true, true, true, true, true,
+/*  9 */ true, ____, ____, ____, ____, true, ____, true, true, true,
+/* 10 */ true, true, true, true, true, true, true, true, true, true,
+/* 11 */ true, true, true, true, true, true, true, true, true, true,
 /* 12 */ true, true, true, ____, ____, ____, ____, ____
 };
 
 /*
  * Identifier chars:
  * -      36:    $
  * -  48..57: 0..9
  * -  65..90: A..Z
@@ -3834,24 +3834,24 @@ const bool js_isidstart[] = {
  * - 97..122: a..z
  */
 const bool js_isident[] = {
 /*       0     1     2     3     4     5     6     7     8     9  */
 /*  0 */ ____, ____, ____, ____, ____, ____, ____, ____, ____, ____,
 /*  1 */ ____, ____, ____, ____, ____, ____, ____, ____, ____, ____,
 /*  2 */ ____, ____, ____, ____, ____, ____, ____, ____, ____, ____,
 /*  3 */ ____, ____, ____, ____, ____, ____, true, ____, ____, ____,
-/*  4 */ ____, ____, ____, ____, ____, ____, ____, ____, true, true, 
+/*  4 */ ____, ____, ____, ____, ____, ____, ____, ____, true, true,
 /*  5 */ true, true, true, true, true, true, true, true, ____, ____,
-/*  6 */ ____, ____, ____, ____, ____, true, true, true, true, true, 
-/*  7 */ true, true, true, true, true, true, true, true, true, true, 
-/*  8 */ true, true, true, true, true, true, true, true, true, true, 
-/*  9 */ true, ____, ____, ____, ____, true, ____, true, true, true, 
-/* 10 */ true, true, true, true, true, true, true, true, true, true, 
-/* 11 */ true, true, true, true, true, true, true, true, true, true, 
+/*  6 */ ____, ____, ____, ____, ____, true, true, true, true, true,
+/*  7 */ true, true, true, true, true, true, true, true, true, true,
+/*  8 */ true, true, true, true, true, true, true, true, true, true,
+/*  9 */ true, ____, ____, ____, ____, true, ____, true, true, true,
+/* 10 */ true, true, true, true, true, true, true, true, true, true,
+/* 11 */ true, true, true, true, true, true, true, true, true, true,
 /* 12 */ true, true, true, ____, ____, ____, ____, ____
 };
 
 /* Whitespace chars: '\t', '\n', '\v', '\f', '\r', ' '. */
 const bool js_isspace[] = {
 /*       0     1     2     3     4     5     6     7     8     9  */
 /*  0 */ ____, ____, ____, ____, ____, ____, ____, ____, ____, true,
 /*  1 */ true, true, true, true, ____, ____, ____, ____, ____, ____,
--- a/js/src/jsstr.h
+++ b/js/src/jsstr.h
@@ -237,17 +237,17 @@ InflateString(JSContext *cx, const char 
               FlationCoding fc = NormalEncoding);
 
 extern char *
 DeflateString(JSContext *cx, const jschar *chars, size_t length);
 
 /*
  * Inflate bytes to JS chars in an existing buffer. 'chars' must be large
  * enough for 'length' jschars. The buffer is NOT null-terminated.
- * 
+ *
  * charsLength must be be initialized with the destination buffer size and, on
  * return, will contain on return the number of copied chars.
  */
 extern bool
 InflateStringToBuffer(JSContext *cx, const char *bytes, size_t length,
                       jschar *chars, size_t *charsLength);
 
 extern bool
--- a/js/src/jstypedarray.h
+++ b/js/src/jstypedarray.h
@@ -310,17 +310,17 @@ IsTypedArray(JSObject *obj)
 
 inline bool
 IsTypedArrayProto(JSObject *obj)
 {
     return IsTypedArrayProtoClass(obj->getClass());
 }
 
 class DataViewObject : public JSObject
-{ 
+{
     static Class protoClass;
 
     static const size_t BYTEOFFSET_SLOT = 0;
     static const size_t BYTELENGTH_SLOT = 1;
     static const size_t BUFFER_SLOT     = 2;
 
   public:
     static const size_t RESERVED_SLOTS  = 3;
--- a/js/src/jsweakmap.cpp
+++ b/js/src/jsweakmap.cpp
@@ -132,17 +132,17 @@ typedef WeakMap<HeapPtrObject, HeapValue
 static ObjectValueMap *
 GetObjectMap(JSObject *obj)
 {
     JS_ASSERT(obj->isWeakMap());
     return (ObjectValueMap *)obj->getPrivate();
 }
 
 static JSObject *
-GetKeyArg(JSContext *cx, CallArgs &args) 
+GetKeyArg(JSContext *cx, CallArgs &args)
 {
     Value *vp = &args[0];
     if (vp->isPrimitive()) {
         JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_NOT_NONNULL_OBJECT);
         return NULL;
     }
     JSObject &key = vp->toObject();
 
@@ -231,17 +231,17 @@ WeakMap_delete(JSContext *cx, unsigned a
     if (args.length() < 1) {
         JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_MORE_ARGS_NEEDED,
                              "WeakMap.delete", "0", "s");
         return false;
     }
     JSObject *key = GetKeyArg(cx, args);
     if (!key)
         return false;
-    
+
     ObjectValueMap *map = GetObjectMap(obj);
     if (map) {
         ObjectValueMap::Ptr ptr = map->lookup(key);
         if (ptr) {
             map->remove(ptr);
             args.rval() = BooleanValue(true);
             return true;
         }
@@ -264,17 +264,17 @@ WeakMap_set(JSContext *cx, unsigned argc
     if (args.length() < 1) {
         JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_MORE_ARGS_NEEDED,
                              "WeakMap.set", "0", "s");
         return false;
     }
     JSObject *key = GetKeyArg(cx, args);
     if (!key)
         return false;
-    
+
     Value value = (args.length() > 1) ? args[1] : UndefinedValue();
 
     ObjectValueMap *map = GetObjectMap(obj);
     if (!map) {
         map = cx->new_<ObjectValueMap>(cx, obj);
         if (!map->init()) {
             cx->delete_(map);
             goto out_of_memory;
--- a/js/src/jswin64.asm
+++ b/js/src/jswin64.asm
@@ -38,12 +38,12 @@
 .CODE
 
 extern fmod:PROC
 
 ; This is a workaround for KB982107 (http://support.microsoft.com/kb/982107)
 js_myfmod PROC FRAME
   .ENDPROLOG
   fnclex
-  jmp  fmod 
+  jmp  fmod
 js_myfmod ENDP
 
 END
--- a/js/src/jswrapper.cpp
+++ b/js/src/jswrapper.cpp
@@ -647,17 +647,17 @@ Reify(JSContext *cx, JSCompartment *orig
     }
 
     close.clear();
     if (!CloseIterator(cx, iterObj))
         return false;
 
     if (isKeyIter)
         return VectorToKeyIterator(cx, obj, ni->flags, keys, vp);
-    return VectorToValueIterator(cx, obj, ni->flags, keys, vp); 
+    return VectorToValueIterator(cx, obj, ni->flags, keys, vp);
 }
 
 bool
 CrossCompartmentWrapper::iterate(JSContext *cx, JSObject *wrapper, unsigned flags, Value *vp)
 {
     PIERCE(cx, wrapper, GET,
            NOTHING,
            Wrapper::iterate(cx, wrapper, flags, vp),
@@ -725,17 +725,17 @@ CrossCompartmentWrapper::nativeCall(JSCo
     AutoCompartment call(cx, wrapped);
     if (!call.enter())
         return false;
 
     InvokeArgsGuard dstArgs;
     if (!cx->stack.pushInvokeArgs(cx, srcArgs.length(), &dstArgs))
         return false;
 
-    Value *src = srcArgs.base(); 
+    Value *src = srcArgs.base();
     Value *srcend = srcArgs.array() + srcArgs.length();
     Value *dst = dstArgs.base();
     for (; src != srcend; ++src, ++dst) {
         *dst = *src;
         if (!call.destination->wrap(cx, dst))
             return false;
     }
 
--- a/js/src/methodjit/BaseAssembler.h
+++ b/js/src/methodjit/BaseAssembler.h
@@ -343,17 +343,17 @@ static const JSC::MacroAssembler::Regist
         return (alignment - (bytes % alignment)) % alignment;
     }
 
     // Specifies extra stack space that is available across a call, for storing
     // large parameters (structs) or returning values via references. All extra
     // stack space must be reserved up-front, and is aligned on an 8-byte
     // boundary.
     //
-    // Returns an offset that can be used to index into this stack 
+    // Returns an offset that can be used to index into this stack
     StackMarker allocStack(uint32_t bytes, uint32_t alignment = 4) {
         bytes += align(bytes + extraStackSpace, alignment);
         subPtr(Imm32(bytes), stackPointerRegister);
         extraStackSpace += bytes;
         return StackMarker(extraStackSpace, bytes);
     }
 
     // Similar to allocStack(), but combines it with a push().
--- a/js/src/methodjit/Compiler.cpp
+++ b/js/src/methodjit/Compiler.cpp
@@ -1299,17 +1299,17 @@ mjit::Compiler::finishThisUp()
     stubcc.masm.forceFlushConstantPool();
 #endif
     JaegerSpew(JSpew_Insns, "## Fast code (masm) size = %lu, Slow code (stubcc) size = %lu.\n",
                (unsigned long) masm.size(), (unsigned long) stubcc.size());
 
     /* To make inlineDoubles and oolDoubles aligned to sizeof(double) bytes,
        MIPS adds extra sizeof(double) bytes to codeSize.  */
     size_t codeSize = masm.size() +
-#if defined(JS_CPU_MIPS) 
+#if defined(JS_CPU_MIPS)
                       stubcc.size() + sizeof(double) +
 #else
                       stubcc.size() +
 #endif
                       (masm.numDoubles() * sizeof(double)) +
                       (stubcc.masm.numDoubles() * sizeof(double)) +
                       jumpTableEdges.length() * sizeof(void *);
 
@@ -1746,17 +1746,17 @@ mjit::Compiler::finishThisUp()
     JS_ASSERT(size_t(cursor - (uint8_t*)chunk) == dataSize);
     /* Use the computed size here -- we don't want slop bytes to be counted. */
     JS_ASSERT(chunk->computedSizeOfIncludingThis() == dataSize);
 
     /* Link fast and slow paths together. */
     stubcc.fixCrossJumps(result, masm.size(), masm.size() + stubcc.size());
 
 #if defined(JS_CPU_MIPS)
-    /* Make sure doubleOffset is aligned to sizeof(double) bytes.  */ 
+    /* Make sure doubleOffset is aligned to sizeof(double) bytes.  */
     size_t doubleOffset = (((size_t)result + masm.size() + stubcc.size() +
                             sizeof(double) - 1) & (~(sizeof(double) - 1))) -
                           (size_t)result;
     JS_ASSERT((((size_t)result + doubleOffset) & 7) == 0);
 #else
     size_t doubleOffset = masm.size() + stubcc.size();
 #endif
 
--- a/js/src/methodjit/Compiler.h
+++ b/js/src/methodjit/Compiler.h
@@ -485,17 +485,17 @@ private:
 #ifdef JS_MONOIC
     Label argsCheckStub;
     Label argsCheckFallthrough;
     Jump argsCheckJump;
 #endif
     bool debugMode_;
     bool inlining_;
     bool hasGlobalReallocation;
-    bool oomInVector;       // True if we have OOM'd appending to a vector. 
+    bool oomInVector;       // True if we have OOM'd appending to a vector.
     bool overflowICSpace;   // True if we added a constant pool in a reserved space.
     uint64_t gcNumber;
     PCLengthEntry *pcLengths;
 
     Compiler *thisFromCtor() { return this; }
 
     friend class CompilerAllocPolicy;
   public:
@@ -797,34 +797,34 @@ private:
 
     /* Fast builtins. */
     JSObject *pushedSingleton(unsigned pushed);
     CompileStatus inlineNativeFunction(uint32_t argc, bool callingNew);
     CompileStatus inlineScriptedFunction(uint32_t argc, bool callingNew);
     CompileStatus compileMathAbsInt(FrameEntry *arg);
     CompileStatus compileMathAbsDouble(FrameEntry *arg);
     CompileStatus compileMathSqrt(FrameEntry *arg);
-    CompileStatus compileMathMinMaxDouble(FrameEntry *arg1, FrameEntry *arg2, 
-                                          Assembler::DoubleCondition cond); 
-    CompileStatus compileMathMinMaxInt(FrameEntry *arg1, FrameEntry *arg2, 
-                                       Assembler::Condition cond);                                       
+    CompileStatus compileMathMinMaxDouble(FrameEntry *arg1, FrameEntry *arg2,
+                                          Assembler::DoubleCondition cond);
+    CompileStatus compileMathMinMaxInt(FrameEntry *arg1, FrameEntry *arg2,
+                                       Assembler::Condition cond);
     CompileStatus compileMathPowSimple(FrameEntry *arg1, FrameEntry *arg2);
     CompileStatus compileArrayPush(FrameEntry *thisv, FrameEntry *arg);
     CompileStatus compileArrayConcat(types::TypeSet *thisTypes, types::TypeSet *argTypes,
                                      FrameEntry *thisValue, FrameEntry *argValue);
     CompileStatus compileArrayPopShift(FrameEntry *thisv, bool isPacked, bool isArrayPop);
     CompileStatus compileArrayWithLength(uint32_t argc);
     CompileStatus compileArrayWithArgs(uint32_t argc);
 
     enum RoundingMode { Floor, Round };
     CompileStatus compileRound(FrameEntry *arg, RoundingMode mode);
 
     enum GetCharMode { GetChar, GetCharCode };
     CompileStatus compileGetChar(FrameEntry *thisValue, FrameEntry *arg, GetCharMode mode);
-    
+
     CompileStatus compileStringFromCode(FrameEntry *arg);
     CompileStatus compileParseInt(JSValueType argType, uint32_t argc);
 
     void prepareStubCall(Uses uses);
     Call emitStubCall(void *ptr, DataLabelPtr *pinline);
 };
 
 // Given a stub call, emits the call into the inline assembly path. rejoin
--- a/js/src/methodjit/FastArithmetic.cpp
+++ b/js/src/methodjit/FastArithmetic.cpp
@@ -344,36 +344,36 @@ mjit::Compiler::jsop_binary_double(Frame
         allocateRight = false;
     } else {
         rhsNotNumber = loadDouble(rhs, &fpRight, &allocateRight);
         if (rhsNotNumber.isSet())
             stubcc.linkExit(rhsNotNumber.get(), Uses(2));
     }
 
     EmitDoubleOp(op, fpRight, fpLeft, masm);
-    
+
     MaybeJump done;
 
     /*
      * Try to convert result to integer, if the result has unknown or integer type.
      * Skip this for 1/x or -1/x, as the result is unlikely to fit in an int.
      */
     if (op == JSOP_DIV &&
         (type == JSVAL_TYPE_INT32 ||
          (type == JSVAL_TYPE_UNKNOWN &&
           !(lhs->isConstant() && lhs->isType(JSVAL_TYPE_INT32) &&
             abs(lhs->getValue().toInt32()) == 1)))) {
         RegisterID reg = frame.allocReg();
         FPRegisterID fpReg = frame.allocFPReg();
         JumpList isDouble;
         masm.branchConvertDoubleToInt32(fpLeft, reg, isDouble, fpReg);
-        
+
         masm.storeValueFromComponents(ImmType(JSVAL_TYPE_INT32), reg,
                                       frame.addressOf(lhs));
-        
+
         frame.freeReg(reg);
         frame.freeReg(fpReg);
         done.setJump(masm.jump());
 
         isDouble.linkTo(masm.label(), &masm);
     }
 
     /*
@@ -475,17 +475,17 @@ mjit::Compiler::jsop_binary_full_simple(
 
       case JSOP_MUL:
         overflow = masm.branchMul32(Assembler::Overflow, regs.result, regs.result);
         break;
 
       default:
         JS_NOT_REACHED("unrecognized op");
     }
-    
+
     JS_ASSERT(overflow.isSet());
 
     /*
      * Integer overflow path. Restore the original values and make a stub call,
      * which could trigger recompilation.
      */
     stubcc.linkExitDirect(overflow.get(), stubcc.masm.label());
     frame.rematBinary(fe, NULL, regs, stubcc.masm);
@@ -580,17 +580,17 @@ mjit::Compiler::jsop_binary_full(FrameEn
         emitRightDoublePath(lhs, rhs, regs, rhsNotNumber2);
 
     /* Perform the double addition. */
     MaybeJump doublePathDone;
     if (masm.supportsFloatingPoint() && (!rhs->isTypeKnown() || !lhs->isTypeKnown())) {
         /* If the LHS type was not known, link its path here. */
         if (lhsUnknownDone.isSet())
             lhsUnknownDone.get().linkTo(stubcc.masm.label(), &stubcc.masm);
-        
+
         /* Perform the double operation. */
         EmitDoubleOp(op, regs.rhsFP, regs.lhsFP, stubcc.masm);
 
         /* Force the double back to memory. */
         Address result = frame.addressOf(lhs);
         stubcc.masm.storeDouble(regs.lhsFP, result);
 
         /* Load the payload into the result reg so the rejoin is safe. */
@@ -716,17 +716,17 @@ mjit::Compiler::jsop_binary_full(FrameEn
         }
         break;
       }
 
       default:
         JS_NOT_REACHED("unrecognized op");
     }
     op = origOp;
-    
+
     /*
      * Integer overflow path. Restore the original values and make a stub call,
      * which could trigger recompilation.
      */
     MaybeJump overflowDone;
     if (preOverflow.isSet())
         stubcc.linkExitDirect(preOverflow.get(), stubcc.masm.label());
     if (overflow.isSet())
@@ -1158,17 +1158,17 @@ mjit::Compiler::jsop_equality_int_string
 
         bool needIntPath = (!lhs->isTypeKnown() || lhsInt) && (!rhs->isTypeKnown() || rhsInt);
 
         frame.pop();
         frame.pop();
         frame.discardFrame();
 
         bool needStub = true;
-        
+
 #ifdef JS_MONOIC
         EqualityGenInfo ic;
 
         ic.cond = cond;
         ic.tempReg = tempReg;
         ic.lvr = lvr;
         ic.rvr = rvr;
         ic.stubEntry = stubEntry;
@@ -1391,17 +1391,17 @@ mjit::Compiler::emitRightDoublePath(Fram
 }
 
 static inline Assembler::DoubleCondition
 DoubleCondForOp(JSOp op, JSOp fused)
 {
     bool ifeq = fused == JSOP_IFEQ;
     switch (op) {
       case JSOP_GT:
-        return ifeq 
+        return ifeq
                ? Assembler::DoubleLessThanOrEqualOrUnordered
                : Assembler::DoubleGreaterThan;
       case JSOP_GE:
         return ifeq
                ? Assembler::DoubleLessThanOrUnordered
                : Assembler::DoubleGreaterThanOrEqual;
       case JSOP_LT:
         return ifeq
@@ -1653,17 +1653,17 @@ mjit::Compiler::jsop_relational_full(JSO
         frame.sync(stubcc.masm, Uses(frame.frameSlots()));
         stubcc.leave();
         OOL_STUBCALL(stub, REJOIN_BRANCH);
 
         /* Forget the world, preserving data. */
         frame.pinReg(cmpReg);
         if (reg.isSet())
             frame.pinReg(reg.reg());
-        
+
         frame.popn(2);
 
         frame.syncAndKillEverything();
         frame.unpinKilledReg(cmpReg);
         if (reg.isSet())
             frame.unpinKilledReg(reg.reg());
         frame.freeReg(regs.lhsFP);
         frame.freeReg(regs.rhsFP);
--- a/js/src/methodjit/FastBuiltins.cpp
+++ b/js/src/methodjit/FastBuiltins.cpp
@@ -170,17 +170,17 @@ mjit::Compiler::compileMathSqrt(FrameEnt
 
     frame.popn(3);
     frame.pushDouble(fpResultReg);
 
     return Compile_Okay;
 }
 
 CompileStatus
-mjit::Compiler::compileMathMinMaxDouble(FrameEntry *arg1, FrameEntry *arg2, 
+mjit::Compiler::compileMathMinMaxDouble(FrameEntry *arg1, FrameEntry *arg2,
                                         Assembler::DoubleCondition cond)
 {
     FPRegisterID fpReg1;
     FPRegisterID fpReg2;
     bool allocate;
 
     DebugOnly<MaybeJump> notNumber = loadDouble(arg1, &fpReg1, &allocate);
     JS_ASSERT(!((MaybeJump)notNumber).isSet());
@@ -192,20 +192,20 @@ mjit::Compiler::compileMathMinMaxDouble(
     }
 
     DebugOnly<MaybeJump> notNumber2 = loadDouble(arg2, &fpReg2, &allocate);
     JS_ASSERT(!((MaybeJump)notNumber2).isSet());
 
 
     /* Slow path for 0 and NaN, because they have special requriments. */
     masm.zeroDouble(Registers::FPConversionTemp);
-    Jump zeroOrNan = masm.branchDouble(Assembler::DoubleEqualOrUnordered, fpReg1, 
+    Jump zeroOrNan = masm.branchDouble(Assembler::DoubleEqualOrUnordered, fpReg1,
                                        Registers::FPConversionTemp);
     stubcc.linkExit(zeroOrNan, Uses(4));
-    Jump zeroOrNan2 = masm.branchDouble(Assembler::DoubleEqualOrUnordered, fpReg2, 
+    Jump zeroOrNan2 = masm.branchDouble(Assembler::DoubleEqualOrUnordered, fpReg2,
                                         Registers::FPConversionTemp);
     stubcc.linkExit(zeroOrNan2, Uses(4));
 
 
     Jump ifTrue = masm.branchDouble(cond, fpReg1, fpReg2);
     masm.moveDouble(fpReg2, fpReg1);
 
     ifTrue.linkTo(masm.label(), &masm);
@@ -844,40 +844,40 @@ mjit::Compiler::compileParseInt(JSValueT
 
     if (argType == JSVAL_TYPE_INT32) {
         if (needStubCall) {
             stubcc.leave();
             stubcc.masm.move(Imm32(argc), Registers::ArgReg1);
             OOL_STUBCALL(stubs::SlowCall, REJOIN_FALLTHROUGH);
         }
 
-        /* 
+        /*
          * Stack looks like callee, this, arg1, arg2, argN.
          * First pop all args other than arg1.
          */
         frame.popn(argc - 1);
         /* "Shimmy" arg1 to the callee slot and pop this + arg1. */
         frame.shimmy(2);
 
         if (needStubCall) {
             stubcc.rejoin(Changes(1));
-        }        
+        }
     } else {
         FrameEntry *arg = frame.peek(-(int32_t)argc);
         FPRegisterID fpScratchReg = frame.allocFPReg();
         FPRegisterID fpReg;
         bool allocate;
 
         DebugOnly<MaybeJump> notNumber = loadDouble(arg, &fpReg, &allocate);
         JS_ASSERT(!((MaybeJump)notNumber).isSet());
 
         masm.slowLoadConstantDouble(1, fpScratchReg);
 
         /* Slow path for NaN and numbers < 1. */
-        Jump lessThanOneOrNan = masm.branchDouble(Assembler::DoubleLessThanOrUnordered, 
+        Jump lessThanOneOrNan = masm.branchDouble(Assembler::DoubleLessThanOrUnordered,
                                                   fpReg, fpScratchReg);
         stubcc.linkExit(lessThanOneOrNan, Uses(2 + argc));
 
         frame.freeReg(fpScratchReg);
 
         /* Truncate to integer, slow path if this overflows. */
         RegisterID reg = frame.allocReg();
         Jump overflow = masm.branchTruncateDoubleToInt32(fpReg, reg);
@@ -891,17 +891,17 @@ mjit::Compiler::compileParseInt(JSValueT
         OOL_STUBCALL(stubs::SlowCall, REJOIN_FALLTHROUGH);
 
         frame.popn(2 + argc);
         frame.pushTypedPayload(JSVAL_TYPE_INT32, reg);
 
         stubcc.rejoin(Changes(1));
     }
 
-    return Compile_Okay;   
+    return Compile_Okay;
 }
 
 CompileStatus
 mjit::Compiler::inlineNativeFunction(uint32_t argc, bool callingNew)
 {
     if (!cx->typeInferenceEnabled())
         return Compile_InlineAbort;
 
@@ -1049,17 +1049,17 @@ mjit::Compiler::inlineNativeFunction(uin
         {
             Value arg2Value = arg2->getValue();
             if (arg2Value.toDouble() == -0.5 || arg2Value.toDouble() == 0.5)
                 return compileMathPowSimple(arg1, arg2);
         }
         if ((native == js_math_min || native == js_math_max)) {
             if (arg1Type == JSVAL_TYPE_INT32 && arg2Type == JSVAL_TYPE_INT32 &&
                 type == JSVAL_TYPE_INT32) {
-                return compileMathMinMaxInt(arg1, arg2, 
+                return compileMathMinMaxInt(arg1, arg2,
                         native == js_math_min ? Assembler::LessThan : Assembler::GreaterThan);
             }
             if ((arg1Type == JSVAL_TYPE_INT32 || arg1Type == JSVAL_TYPE_DOUBLE) &&
                 (arg2Type == JSVAL_TYPE_INT32 || arg2Type == JSVAL_TYPE_DOUBLE) &&
                 type == JSVAL_TYPE_DOUBLE) {
                 return compileMathMinMaxDouble(arg1, arg2,
                         (native == js_math_min)
                         ? Assembler::DoubleLessThan
--- a/js/src/methodjit/FastOps.cpp
+++ b/js/src/methodjit/FastOps.cpp
@@ -316,17 +316,17 @@ mjit::Compiler::jsop_bitop(JSOp op)
                 if (op == JSOP_LSH)
                     masm.lshift32(Imm32(shift), reg);
                 else if (op == JSOP_RSH)
                     masm.rshift32(Imm32(shift), reg);
                 else
                     masm.urshift32(Imm32(shift), reg);
             }
             frame.popn(2);
-            
+
             /* x >>> 0 may result in a double, handled above. */
             JS_ASSERT_IF(op == JSOP_URSH, shift >= 1);
             frame.pushTypedPayload(JSVAL_TYPE_INT32, reg);
 
             stubcc.rejoin(Changes(1));
             return;
         }
 #if defined(JS_CPU_X86) || defined(JS_CPU_X64)
@@ -348,24 +348,24 @@ mjit::Compiler::jsop_bitop(JSOp op)
             if (lhs->isConstant()) {
                 reg = frame.allocReg();
                 masm.move(Imm32(lhs->getValue().toInt32()), reg);
             } else {
                 reg = frame.copyDataIntoReg(lhs);
             }
             frame.unpinReg(rr);
         }
-        
+
         if (op == JSOP_LSH) {
             masm.lshift32(rr, reg);
         } else if (op == JSOP_RSH) {
             masm.rshift32(rr, reg);
         } else {
             masm.urshift32(rr, reg);
-            
+
             Jump isNegative = masm.branch32(Assembler::LessThan, reg, Imm32(0));
             stubcc.linkExit(isNegative, Uses(2));
         }
         break;
       }
 
       default:
         JS_NOT_REACHED("NYI");
@@ -690,17 +690,17 @@ mjit::Compiler::jsop_not()
     /* Patch up jumps. */
     stubcc.linkExitDirect(jmpNotBool, lblMaybeInt32);
 
     jmpNotInt32.linkTo(lblMaybeObject, &stubcc.masm);
     stubcc.crossJump(jmpInt32Exit, lblRejoin);
 
     jmpNotObject.linkTo(syncTarget, &stubcc.masm);
     stubcc.crossJump(jmpObjectExit, lblRejoin);
-    
+
 
     /* Leave. */
     stubcc.leave();
     OOL_STUBCALL(stubs::Not, REJOIN_FALLTHROUGH);
 
     frame.pop();
     frame.pushTypedPayload(JSVAL_TYPE_BOOLEAN, data);
 
@@ -750,17 +750,17 @@ mjit::Compiler::jsop_typeof()
 
         if (op == JSOP_STRICTEQ || op == JSOP_EQ || op == JSOP_STRICTNE || op == JSOP_NE) {
             JSAtom *atom = script->getAtom(GET_UINT32_INDEX(PC + JSOP_TYPEOF_LENGTH));
             JSRuntime *rt = cx->runtime;
             JSValueType type = JSVAL_TYPE_UNKNOWN;
             Assembler::Condition cond = (op == JSOP_STRICTEQ || op == JSOP_EQ)
                                         ? Assembler::Equal
                                         : Assembler::NotEqual;
-            
+
             if (atom == rt->atomState.typeAtoms[JSTYPE_VOID]) {
                 type = JSVAL_TYPE_UNDEFINED;
             } else if (atom == rt->atomState.typeAtoms[JSTYPE_STRING]) {
                 type = JSVAL_TYPE_STRING;
             } else if (atom == rt->atomState.typeAtoms[JSTYPE_BOOLEAN]) {
                 type = JSVAL_TYPE_BOOLEAN;
             } else if (atom == rt->atomState.typeAtoms[JSTYPE_NUMBER]) {
                 type = JSVAL_TYPE_INT32;
@@ -895,17 +895,17 @@ mjit::Compiler::jsop_ifneq(JSOp op, jsby
 
 bool
 mjit::Compiler::jsop_andor(JSOp op, jsbytecode *target)
 {
     FrameEntry *fe = frame.peek(-1);
 
     if (fe->isConstant()) {
         JSBool b = js_ValueToBoolean(fe->getValue());
-        
+
         /* Short-circuit. */
         if ((op == JSOP_OR && b == JS_TRUE) ||
             (op == JSOP_AND && b == JS_FALSE)) {
             if (!frame.syncForBranch(target, Uses(0)))
                 return false;
             if (!jumpAndRun(masm.jump(), target))
                 return false;
         }
@@ -923,17 +923,17 @@ mjit::Compiler::jsop_localinc(JSOp op, u
     restoreVarType();
 
     types::TypeSet *types = pushedTypeSet(0);
     JSValueType type = types ? types->getKnownTypeTag(cx) : JSVAL_TYPE_UNKNOWN;
 
     int amt = (op == JSOP_LOCALINC || op == JSOP_INCLOCAL) ? 1 : -1;
 
     if (!analysis->incrementInitialValueObserved(PC)) {
-        // Before: 
+        // Before:
         // After:  V
         frame.pushLocal(slot);
 
         // Before: V
         // After:  V 1
         frame.push(Int32Value(-amt));
 
         // Note, SUB will perform integer conversion for us.
@@ -986,17 +986,17 @@ mjit::Compiler::jsop_arginc(JSOp op, uin
     restoreVarType();
 
     types::TypeSet *types = pushedTypeSet(0);
     JSValueType type = types ? types->getKnownTypeTag(cx) : JSVAL_TYPE_UNKNOWN;
 
     int amt = (op == JSOP_ARGINC || op == JSOP_INCARG) ? 1 : -1;
 
     if (!analysis->incrementInitialValueObserved(PC)) {
-        // Before: 
+        // Before:
         // After:  V
         frame.pushArg(slot);
 
         // Before: V
         // After:  V 1
         frame.push(Int32Value(-amt));
 
         // Note, SUB will perform integer conversion for us.
@@ -1598,17 +1598,17 @@ mjit::Compiler::jsop_setelem(bool popGua
         pinnedIdData = frame.maybePinData(id);
 
     // Note: The fact that |obj| and |value|, or |id| and |value| can be
     // copies, is a little complicated, but it is safe. Explanations
     // follow at each point. Keep in mind two points:
     //  1) maybePin() never allocates a register, it only pins if a register
     //     already existed.
     //  2) tempRegForData() will work fine on a pinned register.
- 
+
     // Guard that the object is an object.
     if (!obj->isTypeKnown()) {
         Jump j = frame.testObject(Assembler::NotEqual, obj);
         stubcc.linkExit(j, Uses(3));
     }
 
     // Guard that the id is int32.
     if (!id->isTypeKnown()) {
@@ -2428,17 +2428,17 @@ mjit::Compiler::jsop_stricteq(JSOp op)
             return;
         }
 
         RegisterID data = frame.copyDataIntoReg(test);
 
         RegisterID result = data;
         if (!(Registers::maskReg(data) & Registers::SingleByteRegs))
             result = frame.allocReg(Registers::SingleByteRegs).reg();
-        
+
         Jump notBoolean;
         if (!test->isTypeKnown())
            notBoolean = frame.testBoolean(Assembler::NotEqual, test);
 
         /* Do a dynamic test. */
         bool val = lhsTest ? lhs->getValue().toBoolean() : rhs->getValue().toBoolean();
         masm.set32(cond, data, Imm32(val), result);
 
--- a/js/src/methodjit/FrameState-inl.h
+++ b/js/src/methodjit/FrameState-inl.h
@@ -170,17 +170,17 @@ FrameState::modifyReg(AnyRegisterID reg)
 
 inline void
 FrameState::convertInt32ToDouble(Assembler &masm, FrameEntry *fe, FPRegisterID fpreg) const
 {
     JS_ASSERT(!fe->isConstant());
 
     if (fe->isCopy())
         fe = fe->copyOf();
-    
+
     if (fe->data.inRegister())
         masm.convertInt32ToDouble(fe->data.reg(), fpreg);
     else
         masm.convertInt32ToDouble(masm.payloadOf(addressOf(fe)), fpreg);
 }
 
 inline bool
 FrameState::peekTypeInRegister(FrameEntry *fe) const
@@ -746,17 +746,17 @@ FrameState::ensureFeSynced(const FrameEn
         else if (backing->isTypeKnown())
             masm.storeValueFromComponents(ImmType(backing->getKnownType()), backing->data.reg(), to);
         else
             masm.storeValueFromComponents(backing->type.reg(), backing->data.reg(), to);
         return;
     }
 #endif
 
-    /* 
+    /*
      * On x86_64, only one of the following two calls will have output,
      * and a load will only occur if necessary.
      */
     ensureDataSynced(fe, masm);
     ensureTypeSynced(fe, masm);
 }
 
 inline void
@@ -786,17 +786,17 @@ FrameState::ensureTypeSynced(const Frame
         return;
     }
 #endif
 
     /* Store a double's type bits, even though !isTypeKnown(). */
     if (backing->isConstant())
         masm.storeTypeTag(ImmTag(backing->getKnownTag()), to);
     else if (backing->isTypeKnown())
-        masm.storeTypeTag(ImmType(backing->getKnownType()), to); 
+        masm.storeTypeTag(ImmType(backing->getKnownType()), to);
     else
         masm.storeTypeTag(backing->type.reg(), to);
 }
 
 inline void
 FrameState::ensureDataSynced(const FrameEntry *fe, Assembler &masm) const
 {
     if (fe->data.synced())
@@ -1510,17 +1510,17 @@ FrameState::tryFastDoubleLoad(FrameEntry
     return false;
 }
 
 inline void
 FrameState::loadDouble(FrameEntry *fe, FPRegisterID fpReg, Assembler &masm) const
 {
     if (fe->isCopy()) {
         FrameEntry *backing = fe->copyOf();
-        if (tryFastDoubleLoad(fe, fpReg, masm)) 
+        if (tryFastDoubleLoad(fe, fpReg, masm))
             return;
         fe = backing;
     }
 
     if (tryFastDoubleLoad(fe, fpReg, masm))
         return;
 
     ensureFeSynced(fe, masm);
--- a/js/src/methodjit/FrameState.cpp
+++ b/js/src/methodjit/FrameState.cpp
@@ -1035,17 +1035,17 @@ FrameState::storeTo(FrameEntry *fe, Addr
             dreg = allocReg();
             masm.loadPayload(addressOf(fe), dreg.reg());
             canPinDreg = false;
         } else {
             dreg = allocAndLoadReg(fe, false, RematInfo::DATA).reg();
             fe->data.setRegister(dreg.reg());
         }
     }
-    
+
     /* Store the Value. */
     if (fe->type.inRegister()) {
         masm.storeValueFromComponents(fe->type.reg(), dreg.reg(), address);
     } else if (fe->isTypeKnown()) {
         masm.storeValueFromComponents(ImmType(fe->getKnownType()), dreg.reg(), address);
     } else {
         JS_ASSERT(fe->type.inMemory());
         if (canPinDreg)
@@ -1355,17 +1355,17 @@ FrameState::sync(Assembler &masm, Uses u
                 avail.putReg(fe->type.reg());
         } else {
             FrameEntry *backing = fe->copyOf();
             JS_ASSERT(!backing->isConstant() && !fe->isConstant());
 
 #if defined JS_PUNBOX64
             if ((!fe->type.synced() && backing->type.inMemory()) ||
                 (!fe->data.synced() && backing->data.inMemory())) {
-    
+
                 RegisterID syncReg = Registers::ValueReg;
 
                 /* Load the entire Value into syncReg. */
                 if (backing->type.synced() && backing->data.synced()) {
                     masm.loadValue(addressOf(backing), syncReg);
                 } else if (backing->type.inMemory()) {
                     masm.loadTypeTag(addressOf(backing), syncReg);
                     masm.orPtr(backing->data.reg(), syncReg);
@@ -2264,36 +2264,36 @@ FrameState::storeTop(FrameEntry *target)
          *
          *  ENTERBLOCK 2
          *  GETLOCAL 1
          *  SETLOCAL 0
          *
          * The problem is slot N can't be backed by M if M could be popped
          * before N. We want a guarantee that when we pop M, even if it was
          * copied, it has no outstanding copies.
-         * 
+         *
          * Because of |let| expressions, it's kind of hard to really know
          * whether a region on the stack will be popped all at once. Bleh!
          *
          * This should be rare except in browser code (and maybe even then),
          * but even so there's a quick workaround. We take all copies of the
          * backing fe, and redirect them to be copies of the destination.
          */
         for (uint32_t i = backing->trackerIndex() + 1; i < tracker.nentries; i++) {
             FrameEntry *fe = tracker[i];
             if (deadEntry(fe))
                 continue;
             if (fe->isCopy() && fe->copyOf() == backing)
                 fe->setCopyOf(target);
         }
     }
-    
+
     /*
      * This is valid from the top->isCopy() path because we're guaranteed a
-     * consistent ordering - all copies of |backing| are tracked after 
+     * consistent ordering - all copies of |backing| are tracked after
      * |backing|. Transitively, only one swap is needed.
      */
     if (backing->trackerIndex() < target->trackerIndex())
         swapInTracker(backing, target);
 
     if (backing->isType(JSVAL_TYPE_DOUBLE)) {
         FPRegisterID fpreg = tempFPRegForData(backing);
         target->setType(JSVAL_TYPE_DOUBLE);
--- a/js/src/methodjit/FrameState.h
+++ b/js/src/methodjit/FrameState.h
@@ -85,25 +85,25 @@ class LoopState;
  *
  * The register allocator keeps track of registers as being in one of two
  * states. These are:
  *
  * 1) Unowned. Some code in the compiler is working on a register.
  * 2) Owned. The FrameState owns the register, and may spill it at any time.
  *
  * ------------------ Implementation Details ------------------
- * 
+ *
  * Observations:
  *
  * 1) Every time we need a slow call, we must sync everything.
  * 2) Efficient side-exits need to quickly deltize state snapshots.
  * 3) Syncing is limited to constants and registers.
  * 4) Entries are not forgotten unless they are entirely in memory and are
  *    not constants or copies.
- * 
+ *
  * With these in mind, we want to make sure that the compiler doesn't degrade
  * badly as functions get larger.
  *
  * If the FE is NULL, a new one is allocated, initialized, and stored. They
  * are allocated from a pool such that (fe - pool) can be used to compute
  * the slot's Address.
  *
  * We keep a side vector of all tracked FrameEntry * to quickly generate
@@ -356,17 +356,17 @@ class FrameState
      * For example, checking LHS and RHS as ints guarantees that if the LHS
      * was synced, then popping both and pushing a maybe-int32_t does not need
      * to be synced.
      */
     inline void pushNumber(RegisterID payload, bool asInt32 = false);
 
     /*
      * Pushes an int32_t onto the operation stack. This is a specialized version
-     * of pushNumber. The caller must guarantee that (a) an int32_t is to be 
+     * of pushNumber. The caller must guarantee that (a) an int32_t is to be
      * pushed on the inline path, and (b) if any slow path pushes a double,
      * the slow path also stores the double to memory.
      */
     inline void pushInt32(RegisterID payload);
 
     /*
      * Pops a value off the operation stack, freeing any of its resources.
      */
--- a/js/src/methodjit/ICLabels.h
+++ b/js/src/methodjit/ICLabels.h
@@ -57,17 +57,17 @@ namespace ic {
 /* GetPropCompiler */
 struct GetPropLabels : MacroAssemblerTypedefs {
     friend class ::ICOffsetInitializer;
 
     void setValueLoad(MacroAssembler &masm, Label fastPathRejoin, Label fastValueLoad) {
         int offset = masm.differenceBetween(fastPathRejoin, fastValueLoad);
         inlineValueLoadOffset = offset;
 
-        /* 
+        /*
          * Note: the offset between the type and data loads for x86 is asserted
          * in NunboxAssembler::loadValueWithAddressOffsetPatch.
          */
         JS_ASSERT(offset == inlineValueLoadOffset);
         (void) offset;
     }
 
     CodeLocationLabel getValueLoad(CodeLocationLabel fastPathRejoin) {
@@ -125,17 +125,17 @@ struct GetPropLabels : MacroAssemblerTyp
         dslotsLoadOffset = offset;
         JS_ASSERT(offset == dslotsLoadOffset);
     }
 
     void setInlineShapeOffset(int offset) {
         inlineShapeOffset = offset;
         JS_ASSERT(offset == inlineShapeOffset);
     }
-    
+
     void setStubShapeJumpOffset(int offset) {
         stubShapeJumpOffset = offset;
         JS_ASSERT(offset == stubShapeJumpOffset);
     }
 
     int getInlineShapeJumpOffset() {
         return POST_INST_OFFSET(inlineShapeJumpOffset);
     }
@@ -169,17 +169,17 @@ struct GetPropLabels : MacroAssemblerTyp
     int32_t dslotsLoadOffset : 8;
 
     /* Offset from shapeGuard to end of shape comparison. */
     int32_t inlineShapeOffset : 8;
 
     /* Offset from storeBack to end of value load. */
     int32_t inlineValueLoadOffset : 8;
 
-    /* 
+    /*
      * Offset from lastStubStart to end of shape jump.
      * TODO: We can redefine the location of lastStubStart to be
      * after the jump -- at which point this is always 0.
      */
     int32_t stubShapeJumpOffset : 8;
 
     /* Offset from the shape guard start to the shape guard jump. */
     int32_t inlineShapeJumpOffset : 8;
@@ -287,17 +287,17 @@ struct SetPropLabels : MacroAssemblerTyp
     }
 
     /* Offset from storeBack to beginning of 'mov dslots, addr'. */
     int32_t dslotsLoadOffset : 8;
 
     /* Offset from shapeGuard to end of shape comparison. */
     int32_t inlineShapeDataOffset : 8;
 
-    /* 
+    /*
      * Offset from lastStubStart to end of shape jump.
      * TODO: We can redefine the location of lastStubStart to be
      * after the jump -- at which point this is always 0.
      */
     int32_t stubShapeJumpOffset : 8;
 
     int32_t inlineValueStoreOffset : 8;
 
--- a/js/src/methodjit/ICRepatcher.h
+++ b/js/src/methodjit/ICRepatcher.h
@@ -107,17 +107,17 @@ class Repatcher : public JSC::RepatchBuf
         JSC::RepatchBuffer::relink(call.callAtOffset(-8), stub);
 #else
 # error
 #endif
     }
 
     /* Patch the offset of a Value load emitted by loadValueWithAddressOffsetPatch. */
     void patchAddressOffsetForValueLoad(CodeLocationLabel label, uint32_t offset) {
-#if defined JS_CPU_X64 || defined JS_CPU_ARM || defined JS_CPU_SPARC || defined JS_CPU_MIPS 
+#if defined JS_CPU_X64 || defined JS_CPU_ARM || defined JS_CPU_SPARC || defined JS_CPU_MIPS
         repatch(label.dataLabel32AtOffset(0), offset);
 #elif defined JS_CPU_X86
         static const unsigned LOAD_TYPE_OFFSET = 6;
         static const unsigned LOAD_DATA_OFFSET = 12;
 
         /*
          * We have the following sequence to patch:
          *
--- a/js/src/methodjit/InvokeHelpers.cpp
+++ b/js/src/methodjit/InvokeHelpers.cpp
@@ -569,17 +569,17 @@ js_InternalThrow(VMFrame &f)
 
         if (cx->compartment->debugMode()) {
             // This can turn a throw or error into a healthy return. Note that
             // we will run ScriptDebugEpilogue again (from AnyFrameEpilogue);
             // ScriptDebugEpilogue is prepared for this eventuality.
             if (js::ScriptDebugEpilogue(cx, f.fp(), false))
                 return cx->jaegerRuntime().forceReturnFromExternC();
         }
-                
+
 
         ScriptEpilogue(f.cx, f.fp(), false);
 
         // Don't remove the last frame, this is the responsibility of
         // JaegerShot()'s caller. We only guarantee that ScriptEpilogue()
         // has been run.
         if (f.entryfp == f.fp())
             break;
@@ -952,17 +952,17 @@ js_InternalInterpret(void *returnData, v
 
       case REJOIN_FUNCTION_PROLOGUE:
         fp->scopeChain();
 
         /* Construct the 'this' object for the frame if necessary. */
         if (!ScriptPrologueOrGeneratorResume(cx, fp, types::UseNewTypeAtEntry(cx, fp)))
             return js_InternalThrow(f);
 
-        /* 
+        /*
          * Having called ScriptPrologueOrGeneratorResume, we would normally call
          * ScriptDebugPrologue here. But in debug mode, we only use JITted
          * functions' invokeEntry entry point, whereas CheckArgumentTypes
          * (REJOIN_CHECK_ARGUMENTS) and FunctionFramePrologue
          * (REJOIN_FUNCTION_PROLOGUE) are only reachable via the other entry
          * points. So we should never need either of these rejoin tails in debug
          * mode.
          *
--- a/js/src/methodjit/MethodJIT.cpp
+++ b/js/src/methodjit/MethodJIT.cpp
@@ -188,31 +188,31 @@ JS_STATIC_ASSERT(offsetof(FrameRegs, sp)
 
 /*
  * Notes about DWARF Call Frame Information (CFI) annotations:
  *
  * A .cfi directive placed in assembly code describes how to recover the
  * caller's registers when control is at or after that directive. That is,
  * they describe the states that hold between one instruction and the next,
  * not the instructions themselves. Later directives override earlier
- * directives. 
+ * directives.
  *
  * In DWARF CFI, each stack frame has a Canonical Frame Address (CFA) that
  * remains constant throughout the frame's lifetime. Exactly where it is is
  * a matter of convention; on the x86 and x86_64, for example, the CFA
  * points just after the end of the current stack frame: the address of the
  * next word after the return address. The CFI annotations describe 1) how
  * to compute the CFA at each point in the function, and 2) given the CFA,
  * where the caller's value of each register has been saved. (CFI specifies
  * saved registers' locations relative to the CFA, instead of the stack
  * pointer, so that when we push or pop the stack, we need only adjust our
  * rule for computing the CFA, not the rule for each saved register.)
  *
  * Quick reference:
- * 
+ *
  * .cfi_startproc, .cfi_endproc
  *   Put these at the beginning and end of the block of code you're
  *   annotating.
  *
  * (The following directives apply starting at the point they appear until
  * they are overridden or until the .cfi_endproc.)
  *
  * .cfi_def_cfa REGISTER, OFFSET
@@ -222,17 +222,17 @@ JS_STATIC_ASSERT(offsetof(FrameRegs, sp)
  *   The CFA is the value of the same register as before, but now adding OFFSET.
  *
  * .cfi_def_cfa_register REGISTER
  *   The CFA is now the value of REGISTER, adding the same offset as before.
  *
  * .cfi_offset REGISTER, OFFSET
  *   The caller's value of REGISTER is saved at OFFSET from the current CFA.
  *   (This is the directive that actually says something interesting.)
- * 
+ *
  * There are other directives that compute the CFA, a saved register's address,
  * or a saved register's value, in more complex ways, but the above are the ones
  * we use here.
  *
  * Special rules for JaegerThrowpoline and friends:
  *
  * In ordinary code, return addresses always point directly after a call
  * instruction. When GDB looks up the CFI for a return address it got from the
@@ -444,17 +444,17 @@ asm (
     /* See "Special rules for JaegerThrowpoline and friends", above. */
     CFI(".cfi_startproc"                            "\n")
     CFI(".cfi_def_cfa rbp, 16"                      "\n")
     CFI(".cfi_offset rbp, -16"                      "\n")
     CFI(".cfi_offset r12, -24"                      "\n")
     CFI(".cfi_offset r13, -32"                      "\n")
     CFI(".cfi_offset r14, -40"                      "\n")
     CFI(".cfi_offset r15, -48"                      "\n")
-    CFI(".cfi_offset rbx, -56"                      "\n")   
+    CFI(".cfi_offset rbx, -56"                      "\n")
     CFI("nop"                                       "\n")
 ".globl " SYMBOL_STRING(JaegerInterpolineScripted)  "\n"
 SYMBOL_STRING(JaegerInterpolineScripted) ":"        "\n"
     "movq 0x20(%rbx), %rbx"                         "\n" /* load prev */
     "movq %rbx, 0x38(%rsp)"                         "\n"
     "jmp " SYMBOL_STRING_RELOC(JaegerInterpoline)   "\n"
     CFI(".cfi_endproc"                              "\n")
 );
@@ -487,17 +487,17 @@ SYMBOL_STRING(JaegerTrampoline) ":"     
     /* Save non-volatile registers. */
     "pushl %esi"                         "\n"
     CFI(".cfi_offset esi, -12"           "\n")
     "pushl %edi"                         "\n"
     CFI(".cfi_offset edi, -16"           "\n")
     "pushl %ebx"                         "\n"
     CFI(".cfi_offset ebx, -20"           "\n")
 
-    /* Build the JIT frame. Push fields in order, 
+    /* Build the JIT frame. Push fields in order,
      * then align the stack to form esp == VMFrame. */
     "movl  12(%ebp), %ebx"               "\n"   /* load fp */
     "pushl %ebx"                         "\n"   /* unused1 */
     "pushl %ebx"                         "\n"   /* unused0 */
     "pushl $0x0"                         "\n"   /* stubRejoin */
     "pushl %ebx"                         "\n"   /* entryncode */
     "pushl %ebx"                         "\n"   /* entryfp */
     "pushl 20(%ebp)"                     "\n"   /* stackLimit */
@@ -626,17 +626,17 @@ SYMBOL_STRING(JaegerInterpoline) ":"    
 asm (
 ".text\n"
     /* See "Special rules for JaegerThrowpoline and friends", above. */
     CFI(".cfi_startproc"                            "\n")
     CFI(".cfi_def_cfa ebp, 8"                       "\n")
     CFI(".cfi_offset ebp, -8"                       "\n")
     CFI(".cfi_offset esi, -12"                      "\n")
     CFI(".cfi_offset edi, -16"                      "\n")
-    CFI(".cfi_offset ebx, -20"                      "\n")      
+    CFI(".cfi_offset ebx, -20"                      "\n")
     CFI("nop"                                       "\n")
 ".globl " SYMBOL_STRING(JaegerInterpolineScripted)  "\n"
 SYMBOL_STRING(JaegerInterpolineScripted) ":"        "\n"
     "movl 0x10(%ebp), %ebp"                         "\n" /* load prev. :XXX: STATIC_ASSERT this */
     "movl  %ebp, 0x1C(%esp)"                        "\n"
     "jmp " SYMBOL_STRING_RELOC(JaegerInterpoline)   "\n"
     CFI(".cfi_endproc"                              "\n")
 );
@@ -697,21 +697,21 @@ SYMBOL_STRING(JaegerTrampoline) ":"     
      *  [ regs.inlined ]
      *  [ regs.pc      ]
      *  [ regs.sp      ]
      *  [ scratch      ]
      *  [ previous     ]
      *  [ args.ptr2    ]  [ dynamicArgc ]  (union)
      *  [ args.ptr     ]  [ lazyArgsObj ]  (union)
      */
-    
+
     /* Push callee-saved registers. */
 "   push    {r4-r11,lr}"                        "\n"
     /* Push interesting VMFrame content. */
-"   mov     ip, #0"                             "\n"    
+"   mov     ip, #0"                             "\n"
 "   push    {ip}"                               "\n"    /* stubRejoin */
 "   push    {r1}"                               "\n"    /* entryncode */
 "   push    {r1}"                               "\n"    /* entryfp */
 "   push    {r3}"                               "\n"    /* stackLimit */
 "   push    {r0}"                               "\n"    /* cx */
 "   push    {r1}"                               "\n"    /* regs.fp */
     /* Remaining fields are set elsewhere, but we need to leave space for them. */
 "   sub     sp, sp, #(4*7)"                     "\n"
@@ -752,17 +752,17 @@ asm (
 FUNCTION_HEADER_EXTRA
 ".globl " SYMBOL_STRING(JaegerThrowpoline)  "\n"
 SYMBOL_STRING(JaegerThrowpoline) ":"        "\n"
     /* Find the VMFrame pointer for js_InternalThrow. */
 "   mov     r0, sp"                         "\n"
 
     /* Call the utility function that sets up the internal throw routine. */
 "   blx  " SYMBOL_STRING_RELOC(js_InternalThrow) "\n"
-    
+
     /* If js_InternalThrow found a scripted handler, jump to it. Otherwise, tidy
      * up and return. */
 "   cmp     r0, #0"                         "\n"
 "   it      ne"                             "\n"
 "   bxne    r0"                             "\n"
 
     /* Tidy up, then return '0' to represent an unhandled exception. */
 "   mov     r0, sp"                         "\n"
@@ -847,17 +847,17 @@ extern "C" {
             /* Prologue. */
             push ebp;
             mov ebp, esp;
             /* Save non-volatile registers. */
             push esi;
             push edi;
             push ebx;
 
-            /* Build the JIT frame. Push fields in order, 
+            /* Build the JIT frame. Push fields in order,
              * then align the stack to form esp == VMFrame. */
             mov  ebx, [ebp + 12];
             push ebx;
             push ebx;
             push 0x0;
             push ebx;
             push ebx;
             push [ebp + 20];
--- a/js/src/methodjit/MethodJIT.h
+++ b/js/src/methodjit/MethodJIT.h
@@ -27,17 +27,17 @@
  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  * in which case the provisions of the GPL or the LGPL are applicable instead
  * of those above. If you wish to allow use of your version of this file only
  * under the terms of either the GPL or the LGPL, and not to allow others to
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL. 
+ * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #if !defined jsjaeger_h__ && defined JS_METHODJIT
 #define jsjaeger_h__
 
 #ifdef JSGC_INCREMENTAL
 #define JSGC_INCREMENTAL_MJ
@@ -963,17 +963,17 @@ inline void * bsearch_nmap(NativeMapEntr
         /* current unsearched space is from lo-1 to hi-1, inclusive. */
         if (lo > hi)
             return NULL; /* not found */
         size_t mid       = (lo + hi) / 2;
         size_t bcOff_mid = nmap[mid-1].bcOff;
         if (bcOff < bcOff_mid) {
             hi = mid-1;
             continue;
-        } 
+        }
         if (bcOff > bcOff_mid) {
             lo = mid+1;
             continue;
         }
         return nmap[mid-1].ncode;
     }
 }
 
--- a/js/src/methodjit/MonoIC.cpp
+++ b/js/src/methodjit/MonoIC.cpp
@@ -228,17 +228,17 @@ static const uint32_t INLINE_PATH_LENGTH
 class EqualityCompiler : public BaseCompiler
 {
     VMFrame &f;
     EqualityICInfo &ic;
 
     Vector<Jump, 4, SystemAllocPolicy> jumpList;
     Jump trueJump;
     Jump falseJump;
-    
+
   public:
     EqualityCompiler(VMFrame &f, EqualityICInfo &ic)
         : BaseCompiler(f.cx), f(f), ic(ic), jumpList(SystemAllocPolicy())
     {
     }
 
     void linkToStub(Jump j)
     {
@@ -249,41 +249,41 @@ class EqualityCompiler : public BaseComp
     {
         trueJump = j;
     }
 
     void linkFalse(Jump j)
     {
         falseJump = j;
     }
-    
+
     void generateStringPath(Assembler &masm)
     {
         const ValueRemat &lvr = ic.lvr;
         const ValueRemat &rvr = ic.rvr;
 
         JS_ASSERT_IF(lvr.isConstant(), lvr.isType(JSVAL_TYPE_STRING));
         JS_ASSERT_IF(rvr.isConstant(), rvr.isType(JSVAL_TYPE_STRING));
 
         if (!lvr.isType(JSVAL_TYPE_STRING)) {
             Jump lhsFail = masm.testString(Assembler::NotEqual, lvr.typeReg());
             linkToStub(lhsFail);
         }
-        
+
         if (!rvr.isType(JSVAL_TYPE_STRING)) {
             Jump rhsFail = masm.testString(Assembler::NotEqual, rvr.typeReg());
             linkToStub(rhsFail);
         }
 
         RegisterID tmp = ic.tempReg;
-        
+
         /* JSString::isAtom === (lengthAndFlags & ATOM_MASK == 0) */
         JS_STATIC_ASSERT(JSString::ATOM_FLAGS == 0);
         Imm32 atomMask(JSString::ATOM_MASK);
-        
+
         masm.load32(Address(lvr.dataReg(), JSString::offsetOfLengthAndFlags()), tmp);
         Jump lhsNotAtomized = masm.branchTest32(Assembler::NonZero, tmp, atomMask);
         linkToStub(lhsNotAtomized);
 
         if (!rvr.isConstant()) {
             masm.load32(Address(rvr.dataReg(), JSString::offsetOfLengthAndFlags()), tmp);
             Jump rhsNotAtomized = masm.branchTest32(Assembler::NonZero, tmp, atomMask);
             linkToStub(rhsNotAtomized);
@@ -302,22 +302,22 @@ class EqualityCompiler : public BaseComp
         Jump fallthrough = masm.jump();
         linkFalse(fallthrough);
     }
 
     void generateObjectPath(Assembler &masm)
     {
         ValueRemat &lvr = ic.lvr;
         ValueRemat &rvr = ic.rvr;
-        
+
         if (!lvr.isConstant() && !lvr.isType(JSVAL_TYPE_OBJECT)) {
             Jump lhsFail = masm.testObject(Assembler::NotEqual, lvr.typeReg());
             linkToStub(lhsFail);
         }
-        
+
         if (!rvr.isConstant() && !rvr.isType(JSVAL_TYPE_OBJECT)) {
             Jump rhsFail = masm.testObject(Assembler::NotEqual, rvr.typeReg());
             linkToStub(rhsFail);
         }
 
         masm.loadObjClass(lvr.dataReg(), ic.tempReg);
         Jump lhsHasEq = masm.branchPtr(Assembler::NotEqual,
                                        Address(ic.tempReg, offsetof(Class, ext.equality)),
@@ -371,17 +371,17 @@ class EqualityCompiler : public BaseComp
     }
 
     bool update()
     {
         if (!ic.generated) {
             Assembler masm;
             Value rval = f.regs.sp[-1];
             Value lval = f.regs.sp[-2];
-            
+
             if (rval.isObject() && lval.isObject()) {
                 generateObjectPath(masm);
                 ic.generated = true;
             } else if (rval.isString() && lval.isString()) {
                 generateStringPath(masm);
                 ic.generated = true;
             } else {
                 return true;
@@ -508,17 +508,17 @@ mjit::NativeStubEpilogue(VMFrame &f, Ass
 
     *result = done;
     return true;
 }
 
 /*
  * Calls have an inline path and an out-of-line path. The inline path is used
  * in the fastest case: the method has JIT'd code, and |argc == nargs|.
- * 
+ *
  * The inline path and OOL path are separated by a guard on the identity of
  * the callee object. This guard starts as NULL and always fails on the first
  * hit. On the OOL path, the callee is verified to be both a function and a
  * scripted function. If these conditions hold, |ic::Call| is invoked.
  *
  * |ic::Call| first ensures that the callee has JIT code. If it doesn't, the
  * call to |ic::Call| is patched to a slow path. If it does have JIT'd code,
  * the following cases can occur:
@@ -969,17 +969,17 @@ class CallCompiler : public BaseCompiler
 
         // If the function cannot be jitted (generally unjittable or empty script),
         // patch this site to go to a slow path always.
         if (!ucr.codeAddr) {
             if (ucr.unjittable)
                 disable();
             return NULL;
         }
-            
+
         JSFunction *fun = ucr.fun;
         JS_ASSERT(fun);
         JSScript *script = fun->script();
         JS_ASSERT(script);
 
         uint32_t flags = callingNew ? StackFrame::CONSTRUCTING : 0;
 
         if (!ic.hit) {
--- a/js/src/methodjit/NunboxAssembler.h
+++ b/js/src/methodjit/NunboxAssembler.h
@@ -84,17 +84,17 @@ class NunboxAssembler : public JSC::Macr
 #endif
 
   public:
     static const JSC::MacroAssembler::Scale JSVAL_SCALE = JSC::MacroAssembler::TimesEight;
 
     Address payloadOf(Address address) {
         return Address(address.base, address.offset + PAYLOAD_OFFSET);
     }
-  
+
     BaseIndex payloadOf(BaseIndex address) {
         return BaseIndex(address.base, address.index, address.scale, address.offset + PAYLOAD_OFFSET);
     }
 
     Address tagOf(Address address) {
         return Address(address.base, address.offset + TAG_OFFSET);
     }
 
@@ -194,17 +194,17 @@ class NunboxAssembler : public JSC::Macr
         loadTypeTag(address, treg);
         DBGLABEL_NOMASM(endType);
         loadPayload(address, dreg);
         DBGLABEL_NOMASM(endPayload);
         JS_ASSERT(differenceBetween(start, endType) == 6);
         JS_ASSERT(differenceBetween(endType, endPayload) == 6);
         return start;
 #elif defined JS_CPU_ARM || defined JS_CPU_SPARC
-        /* 
+        /*
          * On ARM, the first instruction loads the offset from a literal pool, so the label
          * returned points at that instruction.
          */
         DataLabel32 load = load64WithAddressOffsetPatch(address, treg, dreg);
         JS_ASSERT(differenceBetween(start, load) == 0);
         (void) load;
         return start;
 #elif defined JS_CPU_MIPS
--- a/js/src/methodjit/PolyIC.h
+++ b/js/src/methodjit/PolyIC.h
@@ -159,27 +159,27 @@ class BasePolyIC : public BaseIC {
     bool addPool(JSContext *cx, JSC::ExecutablePool *pool) {
         if (areZeroPools()) {
             u.execPool = pool;
             return true;
         }
         if (isOnePool()) {
             JSC::ExecutablePool *oldPool = u.execPool;
             JS_ASSERT(!isTagged(oldPool));
-            ExecPoolVector *execPools = OffTheBooks::new_<ExecPoolVector>(SystemAllocPolicy()); 
+            ExecPoolVector *execPools = OffTheBooks::new_<ExecPoolVector>(SystemAllocPolicy());
             if (!execPools)
                 return false;
             if (!execPools->append(oldPool) || !execPools->append(pool)) {
                 Foreground::delete_(execPools);
                 return false;
             }
             u.taggedExecPools = tag(execPools);
             return true;
         }
-        return multiplePools()->append(pool); 
+        return multiplePools()->append(pool);
     }
 
   protected:
     void reset() {
         BaseIC::reset();
         if (areZeroPools()) {
             // Common case:  do nothing.
         } else if (isOnePool()) {
@@ -440,17 +440,17 @@ struct PICInfo : public BasePolyIC {
     // For GET caches, whether the access may use the property cache.
     bool cached : 1;
 
     // Offset from start of fast path to initial shape guard.
     uint32_t shapeGuard;
 
     // Possible types of the RHS, for monitored SETPROP PICs.
     types::TypeSet *rhsTypes;
-    
+
     inline bool isSet() const {
         return kind == SET;
     }
     inline bool isGet() const {
         return kind == GET;
     }
     inline bool isBind() const {
         return kind == BIND;
@@ -507,17 +507,17 @@ struct PICInfo : public BasePolyIC {
     }
     ScopeNameLabels &scopeNameLabels() {
         JS_ASSERT(kind == NAME || kind == XNAME);
         return scopeNameLabels_;
     }
 
     // Where in the script did we generate this PIC?
     jsbytecode *pc;
-    
+
     // Index into the script's atom table.
     PropertyName *name;
 
   public:
     void purge(Repatcher &repatcher);
 
   protected:
     // Reset the data members to the state of a fresh PIC before any patching
--- a/js/src/methodjit/PunboxAssembler.h
+++ b/js/src/methodjit/PunboxAssembler.h
@@ -230,17 +230,17 @@ class PunboxAssembler : public JSC::Macr
 
     template <typename T>
     void storePayload(RegisterID reg, T address) {
         /* Not for doubles. */
         loadTypeTag(address, Registers::ValueReg);
         orPtr(reg, Registers::ValueReg);
         storePtr(Registers::ValueReg, valueOf(address));
     }
-    
+
     template <typename T>
     void storePayload(ImmPayload imm, T address) {
         /* Not for doubles. */
         storePtr(imm, valueOf(address));
     }
 
     template <typename T>
     void storeValue(RegisterID reg, T address) {
--- a/js/src/methodjit/Retcon.cpp
+++ b/js/src/methodjit/Retcon.cpp
@@ -432,17 +432,17 @@ Recompiler::clearStackReferences(FreeOp 
     JaegerSpew(JSpew_Recompile, "recompiling script (file \"%s\") (line \"%d\") (length \"%d\")\n",
                script->filename, script->lineno, script->length);
 
     JSCompartment *comp = script->compartment();
     types::AutoEnterTypeInference enter(fop, comp);
 
     /*
      * The strategy for this goes as follows:
-     * 
+     *
      * 1) Scan the stack, looking at all return addresses that could go into JIT
      *    code.
      * 2) If an address corresponds to a call site registered by |callSite| during
      *    the last compilation, patch it to go to the interpoline.
      * 3) Purge the old compiled state.
      */
 
     // Find all JIT'd stack frames to account for return addresses that will
--- a/js/src/methodjit/Retcon.h
+++ b/js/src/methodjit/Retcon.h
@@ -35,17 +35,17 @@
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 /*
  * Retroactive continuity ("retcon") refers to the retroactive modification
- * or reinterpretation of established facts. 
+ * or reinterpretation of established facts.
  */
 
 #if !defined jsjaeger_retcon_h__ && defined JS_METHODJIT
 #define jsjaeger_retcon_h__
 
 #include "jscntxt.h"
 #include "jsscript.h"
 #include "MethodJIT.h"
--- a/js/src/methodjit/StubCalls.cpp
+++ b/js/src/methodjit/StubCalls.cpp
@@ -1317,17 +1317,17 @@ stubs::TableSwitch(VMFrame &f, jsbytecod
 {
     jsbytecode * const originalPC = origPc;
 
     DebugOnly<JSOp> op = JSOp(*originalPC);
     JS_ASSERT(op == JSOP_TABLESWITCH);
 
     uint32_t jumpOffset = GET_JUMP_OFFSET(originalPC);
     jsbytecode *pc = originalPC + JUMP_OFFSET_LEN;
-    
+
     /* Note: compiler adjusts the stack beforehand. */
     Value rval = f.regs.sp[-1];
 
     int32_t tableIdx;
     if (rval.isInt32()) {
         tableIdx = rval.toInt32();
     } else if (rval.isDouble()) {
         double d = rval.toDouble();
@@ -1688,17 +1688,17 @@ stubs::ConvertToTypedInt(JSContext *cx, 
 
     if (vp->isBoolean())
         return vp->toBoolean() ? 1 : 0;
 
     JS_ASSERT(vp->isString());
 
     int32_t i32 = 0;
 #ifdef DEBUG
-    bool success = 
+    bool success =
 #endif
         StringToNumberType<int32_t>(cx, vp->toString(), &i32);
     JS_ASSERT(success);
 
     return i32;
 }
 
 template int32_t JS_FASTCALL stubs::ConvertToTypedInt<true>(JSContext *, Value *);
@@ -1714,17 +1714,17 @@ stubs::ConvertToTypedFloat(JSContext *cx
     } else if (vp->isObject() || vp->isUndefined()) {
         vp->setDouble(js_NaN);
     } else if (vp->isBoolean()) {
         vp->setDouble(vp->toBoolean() ? 1 : 0);
     } else {
         JS_ASSERT(vp->isString());
         double d = 0;
 #ifdef DEBUG
-        bool success = 
+        bool success =
 #endif
             StringToNumberType<double>(cx, vp->toString(), &d);
         JS_ASSERT(success);
         vp->setDouble(d);
     }
 }
 
 void JS_FASTCALL
--- a/js/src/methodjit/StubCalls.h
+++ b/js/src/methodjit/StubCalls.h
@@ -92,17 +92,17 @@ struct UncachedCallResult {
     JSFunction *fun;          // callee function
     void       *codeAddr;     // code address of compiled callee function
     bool       unjittable;    // did we try to JIT and fail?
 
     void init() {
         fun = NULL;
         codeAddr = NULL;
         unjittable = false;
-    }        
+    }
 };
 
 /*
  * Helper functions for stubs and IC functions for calling functions.
  * These functions either execute the function, return a native code
  * pointer that can be used to call the function, or throw.
  */
 void UncachedCallHelper(VMFrame &f, uint32_t argc, bool lowered, UncachedCallResult *ucr);
@@ -214,17 +214,17 @@ void JS_FASTCALL ArrayShift(VMFrame &f);
 
 void JS_FASTCALL WriteBarrier(VMFrame &f, Value *addr);
 void JS_FASTCALL GCThingWriteBarrier(VMFrame &f, Value *addr);
 
 void JS_FASTCALL CrossChunkShim(VMFrame &f, void *edge);
 
 } /* namespace stubs */
 
-/* 
+/*
  * If COND is true, return A; otherwise, return B. This allows us to choose between
  * function template instantiations without running afoul of C++'s overload resolution
  * rules. (Try simplifying, and you'll either see the problem --- or have found a
  * better solution!)
  */
 template<typename FuncPtr>
 inline FuncPtr FunctionTemplateConditional(bool cond, FuncPtr a, FuncPtr b) {
     return cond ? a : b;
--- a/js/src/methodjit/StubCompiler.cpp
+++ b/js/src/methodjit/StubCompiler.cpp
@@ -79,17 +79,17 @@ StubCompiler::syncExit(Uses uses)
         jumpList.append(j2);
     }
 
     Label l = masm.label();
     frame.sync(masm, uses);
     lastGeneration = generation;
 
     JaegerSpew(JSpew_Insns, " ---- END SLOW MERGE CODE ---- \n");
-    
+
     return l;
 }
 
 JSC::MacroAssembler::Label
 StubCompiler::syncExitAndJump(Uses uses)
 {
     Label l = syncExit(uses);
     Jump j2 = masm.jump();
@@ -138,17 +138,17 @@ StubCompiler::leave()
 {
     JaegerSpew(JSpew_Insns, " ---- BEGIN SLOW LEAVE CODE ---- \n");
     for (size_t i = 0; i < jumpList.length(); i++)
         jumpList[i].linkTo(masm.label(), &masm);
     jumpList.clear();
     generation++;
     JaegerSpew(JSpew_Insns, " ---- END SLOW LEAVE CODE ---- \n");
 }
- 
+
 void
 StubCompiler::rejoin(Changes changes)
 {
     JaegerSpew(JSpew_Insns, " ---- BEGIN SLOW RESTORE CODE ---- \n");
 
     frame.merge(masm, changes);
 
     unsigned index = crossJump(masm.jump(), cc.getLabel());
--- a/js/src/methodjit/TrampolineCompiler.cpp
+++ b/js/src/methodjit/TrampolineCompiler.cpp
@@ -93,17 +93,17 @@ TrampolineCompiler::compileTrampoline(Tr
     Assembler masm;
 
     Label entry = masm.label();
     CHECK_RESULT(generator(masm));
     JS_ASSERT(entry.isSet());
 
     bool ok;
     JSC::LinkBuffer buffer(&masm, execAlloc, poolp, &ok, JSC::METHOD_CODE);
-    if (!ok) 
+    if (!ok)
         return false;
     masm.finalize(buffer);
     uint8_t *result = (uint8_t*)buffer.finalizeCodeAddendum().dataLocation();
     *where = JS_DATA_TO_FUNC_PTR(Trampolines::TrampolinePtr, result + masm.distanceOf(entry));
 
     return true;
 }
 
--- a/js/src/methodjit/TrampolineCompiler.h
+++ b/js/src/methodjit/TrampolineCompiler.h
@@ -57,17 +57,17 @@ public:
     { }
 
     bool compile();
     static void release(Trampolines *tramps);
 
 private:
     bool compileTrampoline(Trampolines::TrampolinePtr *where, JSC::ExecutablePool **pool,
                            TrampolineGenerator generator);
-    
+
     /* Generators for trampolines. */
     static bool generateForceReturn(Assembler &masm);
 
 #if (defined(JS_NO_FASTCALL) && defined(JS_CPU_X86)) || defined(_WIN64)
     static bool generateForceReturnFast(Assembler &masm);
 #endif
 
     JSC::ExecutableAllocator *execAlloc;
--- a/js/src/methodjit/TrampolineMIPS.cpp
+++ b/js/src/methodjit/TrampolineMIPS.cpp
@@ -39,28 +39,28 @@
  * ***** END LICENSE BLOCK ***** */
 
 #include "jstypes.h"
 
 /*
  * The MIPS VMFrame is 112 bytes as follows.
  *
  * 108  [ unused4      ] For alignment.
- * 104  [ ra           ] 
+ * 104  [ ra           ]
  * 100  [ gp           ] If PIC code is generated, we will save gp.
- *  96  [ s7           ] 
- *  92  [ s6           ] 
- *  88  [ s5           ] 
- *  84  [ s4           ] 
- *  80  [ s3           ] 
- *  76  [ s2           ] 
- *  72  [ s1           ] 
- *  68  [ s0           ] 
- *  64  [ stubRejoin   ] 
- *  60  [ entrycode    ] 
+ *  96  [ s7           ]
+ *  92  [ s6           ]
+ *  88  [ s5           ]
+ *  84  [ s4           ]
+ *  80  [ s3           ]
+ *  76  [ s2           ]
+ *  72  [ s1           ]
+ *  68  [ s0           ]
+ *  64  [ stubRejoin   ]
+ *  60  [ entrycode    ]
  *  56  [ entryfp      ]
  *  52  [ stkLimit     ]
  *  48  [ cx           ]
  *  44  [ regs.fp_     ]
  *  40  [ regs.inlined_]
  *  36  [ regs.pc      ]
  *  32  [ regs.sp      ]
  *  28  [ scratch      ]
--- a/js/src/methodjit/TrampolineMasmX64.asm
+++ b/js/src/methodjit/TrampolineMasmX64.asm
@@ -72,18 +72,18 @@ JaegerTrampoline PROC FRAME
 
     ; Build the JIT frame.
     ; rcx = cx
     ; rdx = fp
     ; r9 = inlineCallCount
     ; fp must go into rbx
     push    0       ; stubRejoin
     push    rdx     ; entryncode
-    push    rdx     ; entryFp 
-    push    r9      ; inlineCallCount 
+    push    rdx     ; entryFp
+    push    r9      ; inlineCallCount
     push    rcx     ; cx
     push    rdx     ; fp
     mov     rbx, rdx
 
     ; Space for the rest of the VMFrame.
     sub     rsp, 28h
 
     ; This is actually part of the VMFrame.
--- a/js/src/methodjit/TrampolineSUNWX86.s
+++ b/js/src/methodjit/TrampolineSUNWX86.s
@@ -97,17 +97,17 @@ JaegerTrampolineReturn:
 / void *JaegerThrowpoline(js::VMFrame *vmFrame)
 .global JaegerThrowpoline
 .type   JaegerThrowpoline, @function
 JaegerThrowpoline:
     /* For Sun Studio there is no fast call. */
     /* We add the stack by 16 before. */
     addl $0x10, %esp
     /* Align the stack to 16 bytes. */
-    pushl %esp 
+    pushl %esp
     pushl (%esp)
     pushl (%esp)
     pushl (%esp)
     call js_InternalThrow
     /* Bump the stack by 0x2c, as in the basic trampoline, but */
     /* also one more word to clean up the stack for jsl_InternalThrow,*/
     /* and another to balance the alignment above. */
     addl $0x10, %esp
--- a/js/src/methodjit/TrampolineSparc.s
+++ b/js/src/methodjit/TrampolineSparc.s
@@ -9,17 +9,17 @@
 !
 ! Software distributed under the License is distributed on an "AS IS" basis,
 ! WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 ! for the specific language governing rights and limitations under the
 ! License.
 !
 ! The Original Code is Mozilla SpiderMonkey JavaScript 1.9 code, released
 ! May 28, 2008.
-! 
+!
 ! The Initial Developer of the Original Code is
 !    Leon Sha <leon.sha@oracle.com>
 !
 ! Portions created by the Initial Developer are Copyright (C) 2010-2011
 ! the Initial Developer. All Rights Reserved.
 !
 ! Contributor(s):
 !
--- a/js/src/methodjit/TypedArrayIC.h
+++ b/js/src/methodjit/TypedArrayIC.h
@@ -178,17 +178,17 @@ GenConversionForIntArray(Assembler &masm
         masm.setupABICall(Registers::FastCall, 2);
         masm.storeArg(0, masm.vmFrameOffset(offsetof(VMFrame, cx)));
         masm.storeArgAddr(1, masm.addressOfExtra(vp));
 
         typedef int32_t (JS_FASTCALL *Int32CxVp)(JSContext *, Value *);
         Int32CxVp stub;
         if (TypedArray::getType(tarray) == js::TypedArray::TYPE_UINT8_CLAMPED)
             stub = stubs::ConvertToTypedInt<true>;
-        else 
+        else
             stub = stubs::ConvertToTypedInt<false>;
         masm.callWithABI(JS_FUNC_TO_DATA_PTR(void *, stub), false);
         if (vr.dataReg() != Registers::ReturnReg)
             masm.move(Registers::ReturnReg, vr.dataReg());
 
         saveForCall.restore();
         masm.freeStack(vp);
 
@@ -296,17 +296,17 @@ StoreToTypedArray(JSContext *cx, Assembl
       {
         if (!ConstantFoldForIntArray(cx, tarray, &vr))
             return false;
 
         PreserveRegisters saveRHS(masm);
         PreserveRegisters saveLHS(masm);
 
         // There are three tricky situations to handle:
-        //   (1) The RHS needs conversion. saveMask will be stomped, and 
+        //   (1) The RHS needs conversion. saveMask will be stomped, and
         //       the RHS may need to be stomped.
         //   (2) The RHS may need to be clamped, which clobbers it.
         //   (3) The RHS may need to be in a single-byte register.
         //
         // In all of these cases, we try to find a free register that can be
         // used to mutate the RHS. Failing that, we evict an existing volatile
         // register.
         //
--- a/js/src/shell/jsheaptools.cpp
+++ b/js/src/shell/jsheaptools.cpp
@@ -73,17 +73,17 @@ using namespace js;
  * again.
  *
  * So we take a brute-force approach. We reverse the entire graph, and then walk
  * outward from |target| to the representable objects that refer to it, stopping
  * at such objects.
  */
 
 /*
- * A JSTracer that produces a map of the heap with edges reversed. 
+ * A JSTracer that produces a map of the heap with edges reversed.
  *
  * HeapReversers must be allocated in a stack frame. (They contain an AutoArrayRooter,
  * and those must be allocated and destroyed in a stack-like order.)
  *
  * HeapReversers keep all the roots they find in their traversal alive until
  * they are destroyed. So you don't need to worry about nodes going away while
  * you're using them.
  */
@@ -174,17 +174,17 @@ class HeapReverser : public JSTracer {
         JS_TracerInit(this, JS_GetRuntime(cx), traverseEdgeWithThis);
     }
 
     bool init() { return map.init(); }
 
     /* Build a reversed map of the heap in |map|. */
     bool reverseHeap();
 
-  private:    
+  private:
     /*
      * Conservative scanning can, on a whim, decide that a root is no longer a
      * root, and cause bits of our graph to disappear. The 'roots' vector holds
      * all the roots we find alive, and 'rooter' keeps them alive until we're
      * destroyed.
      *
      * Note that AutoArrayRooters must be constructed and destroyed in a
      * stack-like order, so the same rule applies to this HeapReverser. The
@@ -209,17 +209,17 @@ class HeapReverser : public JSTracer {
     /* Class for setting new parent, and then restoring the original. */
     class AutoParent {
       public:
         AutoParent(HeapReverser *reverser, void *newParent) : reverser(reverser) {
             savedParent = reverser->parent;
             reverser->parent = newParent;
         }
         ~AutoParent() {
-            reverser->parent = savedParent; 
+            reverser->parent = savedParent;
         }
       private:
         HeapReverser *reverser;
         void *savedParent;
     };
 
     /* A work item in the stack of nodes whose children we need to traverse. */
     struct Child {
@@ -346,17 +346,17 @@ HeapReverser::getEdgeDescription()
 }
 
 
 /*** class ReferenceFinder ***********************************************************************/
 
 /* A class for finding an object's referrers, given a reversed heap map. */
 class ReferenceFinder {
   public:
-    ReferenceFinder(JSContext *cx, const HeapReverser &reverser) 
+    ReferenceFinder(JSContext *cx, const HeapReverser &reverser)
       : context(cx), reverser(reverser), result(cx) { }
 
     /* Produce an object describing all references to |target|. */
     JSObject *findReferences(HandleObject target);
 
   private:
     /* The context in which to do allocation and error-handling. */
     JSContext *context;
@@ -366,17 +366,17 @@ class ReferenceFinder {
 
     /* The results object we're currently building. */
     RootedVarObject result;
 
     /* A list of edges we've traversed to get to a certain point. */
     class Path {
       public:
         Path(const HeapReverser::Edge &edge, Path *next) : edge(edge), next(next) { }
-        
+
         /*
          * Compute the full path represented by this Path. The result is
          * owned by the caller.
          */
         char *computeName(JSContext *cx);
 
       private:
         const HeapReverser::Edge &edge;
@@ -385,17 +385,17 @@ class ReferenceFinder {
 
     struct AutoNodeMarker {
         AutoNodeMarker(HeapReverser::Node *node) : node(node) { node->marked = true; }
         ~AutoNodeMarker() { node->marked = false; }
       private:
         HeapReverser::Node *node;
     };
 
-    /* 
+    /*
      * Given that we've reached |cell| via |path|, with all Nodes along that
      * path marked, add paths from all reportable objects reachable from cell
      * to |result|.
      */
     bool visit(void *cell, Path *path);
 
     /*
      * If |cell|, of |kind|, is representable as a JavaScript value, return that
@@ -431,17 +431,17 @@ bool
 ReferenceFinder::visit(void *cell, Path *path)
 {
     /* In ReferenceFinder, paths will almost certainly fit on the C++ stack. */
     JS_CHECK_RECURSION(context, return false);
 
     /* Have we reached a root? Always report that. */
     if (!cell)
         return addReferrer(JSVAL_NULL, path);
-        
+
     HeapReverser::Map::Ptr p = reverser.map.lookup(cell);
     JS_ASSERT(p);
     HeapReverser::Node *node = &p->value;
 
     /* Is |cell| a representable cell, reached via a non-empty path? */
     if (path != NULL) {
         jsval representation = representable(cell, node->kind);
         if (!JSVAL_IS_VOID(representation))
@@ -468,17 +468,17 @@ ReferenceFinder::visit(void *cell, Path 
     return true;
 }
 
 char *
 ReferenceFinder::Path::computeName(JSContext *cx)
 {
     /* Walk the edge list and compute the total size of the path. */
     size_t size = 6;
-    for (Path *l = this; l; l = l->next) 
+    for (Path *l = this; l; l = l->next)
         size += strlen(l->edge.name) + (l->next ? 2 : 0);
     size += 1;
 
     char *path = static_cast<char *>(cx->malloc_(size));
     if (!path)
         return NULL;
 
     /*
@@ -572,14 +572,14 @@ FindReferences(JSContext *cx, unsigned a
     if (!reverser.init() || !reverser.reverseHeap())
         return false;
 
     /* Given the reversed map, find the referents of target. */
     ReferenceFinder finder(cx, reverser);
     JSObject *references = finder.findReferences(RootedVarObject(cx, &target.toObject()));
     if (!references)
         return false;
-    
+
     JS_SET_RVAL(cx, vp, OBJECT_TO_JSVAL(references));
     return true;
 }
 
 #endif /* DEBUG */
--- a/js/src/shell/jsoptparse.cpp
+++ b/js/src/shell/jsoptparse.cpp
@@ -115,17 +115,17 @@ PrintParagraph(const char *text, unsigne
     while (*it != '\0') {
         JS_ASSERT(!isspace(*it));
 
         /* Delimit the current token. */
         const char *limit = it;
         while (!isspace(*limit) && *limit != '\0')
             ++limit;
 
-        /* 
+        /*
          * If the current token is longer than the available number of columns,
          * then make a line break before printing the token.
          */
         JS_ASSERT(limit - it > 0);
         size_t tokLen = limit - it;
         JS_ASSERT(tokLen);
         if (tokLen + colno >= limitColno) {
             printf("\n%*s%.*s", startColno, "", int(tokLen), it);
@@ -221,17 +221,17 @@ OptionParser::printHelp(const char *prog
             PrintParagraph(arg->help, lhsLen, helpWidth, false);
             putchar('\n');
         }
         putchar('\n');
     }
 
     if (!options.empty()) {
         printf("Options:\n");
-                                
+
         /* Calculate sizes for column alignment. */
         size_t lhsLen = 0;
         for (Option **it = options.begin(), **end = options.end(); it != end; ++it) {
             Option *opt = *it;
             size_t longflagLen = strlen(opt->longflag);
 
             size_t fmtLen;
             OptionFlagsToFormatInfo(opt->shortflag, opt->isValued(), &fmtLen);
@@ -298,17 +298,17 @@ OptionParser::handleOption(Option *opt, 
     switch (opt->kind) {
       case OptionKindBool:
       {
         if (opt == &helpOption)
             return printHelp(argv[0]);
         opt->asBoolOption()->value = true;
         return Okay;
       }
-      /* 
+      /*
        * Valued options are allowed to specify their values either via
        * successive arguments or a single --longflag=value argument.
        */
       case OptionKindString:
       {
         char *value = NULL;
         if (Result r = extractValue(argc, argv, i, &value))
             return r;
--- a/js/src/shell/jsoptparse.h
+++ b/js/src/shell/jsoptparse.h
@@ -83,17 +83,17 @@ struct Option
     void setTerminatesOptions(bool enabled) { terminatesOptions = enabled; }
     bool getTerminatesOptions() const { return terminatesOptions; }
 
     virtual bool isValued() const { return false; }
 
     /* Only some valued options are variadic (like MultiStringOptions). */
     virtual bool isVariadic() const { return false; }
 
-    /* 
+    /*
      * For arguments, the shortflag field is used to indicate whether the
      * argument is optional.
      */
     bool isOptional() { return shortflag; }
 
     void setFlagInfo(char shortflag, const char *longflag, const char *help) {
         this->shortflag = shortflag;
         this->longflag = longflag;
@@ -202,17 +202,17 @@ class MultiStringRange
     }
 
     bool empty() const { return cur == end; }
     void popFront() { JS_ASSERT(!empty()); ++cur; }
     char *front() const { JS_ASSERT(!empty()); return cur->value; }
     size_t argno() const { JS_ASSERT(!empty()); return cur->argno; }
 };
 
-/* 
+/*
  * Builder for describing a command line interface and parsing the resulting
  * specification.
  *
  * - A multi-option is an option that can appear multiple times and still
  *   parse as valid command line arguments.
  * - An "optional argument" is supported for backwards compatibility with prior
  *   command line interface usage. Once one optional argument has been added,
  *   *only* optional arguments may be added.
@@ -300,17 +300,17 @@ class OptionParser
     int getIntOption(const char *longflag) const;
     const char *getStringOption(char shortflag) const;
     const char *getStringOption(const char *longflag) const;
     bool getBoolOption(char shortflag) const;
     bool getBoolOption(const char *longflag) const;
     MultiStringRange getMultiStringOption(char shortflag) const;
     MultiStringRange getMultiStringOption(const char *longflag) const;
 
-    /* 
+    /*
      * Return whether the help option was present (and thus help was already
      * displayed during parse_args).
      */
     bool getHelpOption() const;
 };
 
 } /* namespace cli */
 } /* namespace js */
--- a/js/src/shell/jsworkers.cpp
+++ b/js/src/shell/jsworkers.cpp
@@ -128,17 +128,17 @@ class Queue {
             js::Reverse(back->begin(), back->end());
             Vec *tmp = front;
             front = back;
             back = tmp;
         }
         T item = front->back();
         front->popBack();
         return item;
-    }        
+    }
 
     void clear() {
         v1.clear();
         v2.clear();
     }
 
     void trace(JSTracer *trc) {
         for (T *p = v1.begin(); p != v1.end(); p++)
@@ -284,17 +284,17 @@ class Event
     WorkerParent *recipient;
     Worker *child;
     uint64_t *data;
     size_t nbytes;
 
   public:
     enum Result { fail = JS_FALSE, ok = JS_TRUE, forwardToParent };
 
-    virtual void destroy(JSContext *cx) { 
+    virtual void destroy(JSContext *cx) {
         JS_free(cx, data);
 #ifdef DEBUG
         data = NULL;
 #endif
         delete this;
     }
 
     void setChildAndRecipient(Worker *aChild, WorkerParent *aRecipient) {
@@ -1231,17 +1231,17 @@ Worker::jsPostMessageToChild(JSContext *
     if (!workerobj)
         return false;
     Worker *w = (Worker *) JS_GetInstancePrivate(cx, workerobj, &jsWorkerClass, JS_ARGV(cx, vp));
     if (!w) {
         if (!JS_IsExceptionPending(cx))
             JS_ReportError(cx, "Worker was shut down");
         return false;
     }
-    
+
     jsval data = argc > 0 ? JS_ARGV(cx, vp)[0] : JSVAL_VOID;
     Event *event = DownMessageEvent::create(cx, w, data);
     if (!event)
         return false;
     if (!w->post(event)) {
         JS_ReportOutOfMemory(cx);
         return false;
     }
--- a/js/src/vm/Debugger.cpp
+++ b/js/src/vm/Debugger.cpp
@@ -223,17 +223,17 @@ class Debugger::FrameRange {
      * Delete the front frame from its Debugger's frame map. After this call,
      * the range's front is invalid until popFront is called.
      */
     void removeFrontFrame() const {
         JS_ASSERT(!empty());
         frontDebugger()->frames.remove(entry);
     }
 
-    void popFront() { 
+    void popFront() {
         JS_ASSERT(!empty());
         nextDebugger++;
         findNext();
     }
 
   private:
     /*
      * Either make this range refer to the first appropriate Debugger.Frame at
@@ -561,29 +561,29 @@ Debugger::slowPathOnLeaveFrame(JSContext
             RootedVarValue handler(cx, frameobj->getReservedSlot(JSSLOT_DEBUGFRAME_ONPOP_HANDLER));
 
             AutoCompartment ac(cx, dbg->object);
 
             if (!ac.enter()) {
                 status = JSTRAP_ERROR;
                 break;
             }
-                
+
             Value completion;
             if (!dbg->newCompletionValue(cx, status, value, &completion)) {
                 status = dbg->handleUncaughtException(ac, NULL, false);
                 break;
             }
 
             /* Call the onPop handler. */
             Value rval;
             bool hookOk = Invoke(cx, ObjectValue(*frameobj), handler, 1, &completion, &rval);
             Value nextValue;
             JSTrapStatus nextStatus = dbg->parseResumptionValue(ac, hookOk, rval, &nextValue);
-            
+
             /*
              * At this point, we are back in the debuggee compartment, and any error has
              * been wrapped up as a completion value.
              */
             JS_ASSERT(cx->compartment == global->compartment());
             JS_ASSERT(!cx->isExceptionPending());
 
             /* JSTRAP_CONTINUE means "make no change". */
@@ -631,17 +631,17 @@ Debugger::slowPathOnLeaveFrame(JSContext
     switch (status) {
       case JSTRAP_RETURN:
         fp->setReturnValue(value);
         return true;
 
       case JSTRAP_THROW:
         cx->setPendingException(value);
         return false;
-        
+
       case JSTRAP_ERROR:
         JS_ASSERT(!cx->isExceptionPending());
         return false;
 
       default:
         JS_NOT_REACHED("bad final trap status");
     }
 }
@@ -781,17 +781,17 @@ Debugger::resultToCompletion(JSContext *
         *status = JSTRAP_ERROR;
         value->setUndefined();
     }
 }
 
 bool
 Debugger::newCompletionValue(JSContext *cx, JSTrapStatus status, Value value, Value *result)
 {
-    /* 
+    /*
      * We must be in the debugger's compartment, since that's where we want
      * to construct the completion value.
      */
     assertSameCompartment(cx, object.get());
 
     RootedVarId key(cx);
     RootValue valueRoot(cx, &value);
 
@@ -1969,27 +1969,27 @@ Debugger::removeDebuggeeGlobal(FreeOp *f
     if (v->empty())
         global->compartment()->removeDebuggee(fop, global, compartmentEnum);
     if (debugEnum)
         debugEnum->removeFront();
     else
         debuggees.remove(global);
 }
 
-/* 
+/*
  * A class for parsing 'findScripts' query arguments and searching for
  * scripts that match the criteria they represent.
  */
 class Debugger::ScriptQuery {
   public:
     /* Construct a ScriptQuery to use matching scripts for |dbg|. */
     ScriptQuery(JSContext *cx, Debugger *dbg):
         cx(cx), debugger(dbg), compartments(cx), innermostForGlobal(cx) {}
 
-    /* 
+    /*
      * Initialize this ScriptQuery. Raise an error and return false if we
      * haven't enough memory.
      */
     bool init() {
         if (!globals.init() ||
             !compartments.init() ||
             !innermostForGlobal.init())
         {
@@ -2085,17 +2085,17 @@ class Debugger::ScriptQuery {
     bool omittedQuery() {
         url.setUndefined();
         hasLine = false;
         innermost = false;
         return matchAllDebuggeeGlobals();
     }
 
     /*
-     * Search all relevant compartments and the stack for scripts matching 
+     * Search all relevant compartments and the stack for scripts matching
      * this query, and append the matching scripts to |vector|.
      */
     bool findScripts(AutoScriptVector *vector) {
         if (!prepareQuery())
             return false;
 
         /* Search each compartment for debuggee scripts. */
         for (CompartmentSet::Range r = compartments.all(); !r.empty(); r.popFront()) {
@@ -2192,58 +2192,58 @@ class Debugger::ScriptQuery {
         JS_ASSERT(globals.count() == 0);
         if (!globals.put(global)) {
             js_ReportOutOfMemory(cx);
             return false;
         }
         return true;
     }
 
-    /* 
+    /*
      * Arrange for this ScriptQuery to match all scripts running in debuggee
      * globals.
      */
     bool matchAllDebuggeeGlobals() {
         JS_ASSERT(globals.count() == 0);
         /* Copy the debugger's set of debuggee globals to our global set. */
         for (GlobalObjectSet::Range r = debugger->debuggees.all(); !r.empty(); r.popFront()) {
             if (!globals.put(r.front())) {
                 js_ReportOutOfMemory(cx);
                 return false;
             }
-        }            
+        }
         return true;
     }
 
-    /* 
+    /*
      * Given that parseQuery or omittedQuery has been called, prepare to
      * match scripts. Set urlCString as appropriate.
      */
     bool prepareQuery() {
         /*
-         * Compute the proper value for |compartments|, given the present 
+         * Compute the proper value for |compartments|, given the present
          * value of |globals|.
          */
         for (GlobalObjectSet::Range r = globals.all(); !r.empty(); r.popFront()) {
             if (!compartments.put(r.front()->compartment())) {
                 js_ReportOutOfMemory(cx);
                 return false;
             }
         }
 
         /* Compute urlCString, if a url was given. */
         if (url.isString()) {
             if (!urlCString.encode(cx, url.toString()))
                 return false;
         }
- 
-        return true;        
+
+        return true;
     }
 
-    /* 
+    /*
      * If |script|, a script in |global|, matches this query, append it to
      * |vector| or place it in |innermostForGlobal|, as appropriate. Return true
      * if no error occurs, false if an error occurs.
      */
     bool consider(JSScript *script, GlobalObject *global, AutoScriptVector *vector) {
         if (!globals.has(global))
             return true;
         if (urlCString.ptr()) {
@@ -2286,18 +2286,18 @@ class Debugger::ScriptQuery {
             }
         } else {
             /* Record this matching script in the results vector. */
             if (!vector->append(script)) {
                 js_ReportOutOfMemory(cx);
                 return false;
             }
         }
-        
-        return true;        
+
+        return true;
     }
 };
 
 JSBool
 Debugger::findScripts(JSContext *cx, unsigned argc, Value *vp)
 {
     THIS_DEBUGGER(cx, argc, vp, "findScripts", args, dbg);
 
--- a/js/src/vm/RegExpStatics-inl.h
+++ b/js/src/vm/RegExpStatics-inl.h
@@ -64,17 +64,17 @@ inline
 RegExpStatics::RegExpStatics()
   : bufferLink(NULL),
     copied(false)
 {
     clear();
 }
 
 inline bool
-RegExpStatics::createDependent(JSContext *cx, size_t start, size_t end, Value *out) const 
+RegExpStatics::createDependent(JSContext *cx, size_t start, size_t end, Value *out) const
 {
     JS_ASSERT(start <= end);
     JS_ASSERT(end <= matchPairsInput->length());
     JSString *str = js_NewDependentString(cx, matchPairsInput, start, end - start);
     if (!str)
         return false;
     *out = StringValue(str);
     return true;
--- a/js/src/vm/Xdr.cpp
+++ b/js/src/vm/Xdr.cpp
@@ -70,36 +70,36 @@ XDRBuffer::freeBuffer()
     memset(this, 0xe2, sizeof *this);
 #endif
 }
 
 bool
 XDRBuffer::grow(size_t n)
 {
     JS_ASSERT(n > size_t(limit - cursor));
-    
+
     const size_t MEM_BLOCK = 8192;
     size_t offset = cursor - base;
     size_t newCapacity = JS_ROUNDUP(offset + n, MEM_BLOCK);
     if (isUint32Overflow(newCapacity)) {
         JS_ReportErrorNumber(cx(), js_GetErrorMessage, NULL, JSMSG_TOO_BIG_TO_ENCODE);
         return false;
     }
-        
+
     void *data = OffTheBooks::realloc_(base, newCapacity);
     if (!data) {
         js_ReportOutOfMemory(cx());
         return false;
     }
     base = static_cast<uint8_t *>(data);
     cursor = base + offset;
     limit = base + newCapacity;
     return true;
 }
-    
+
 template<XDRMode mode>
 bool
 XDRState<mode>::codeChars(jschar *chars, size_t nchars)
 {
     size_t nbytes = nchars * sizeof(jschar);
     if (mode == XDR_ENCODE) {
         uint8_t *ptr = buf.write(nbytes);
         if (!ptr)
@@ -150,17 +150,17 @@ VersionCheck(XDRState<mode> *xdr)
 }
 
 template<XDRMode mode>
 bool
 XDRState<mode>::codeFunction(JSObject **objp)
 {
     if (mode == XDR_DECODE)
         *objp = NULL;
-        
+
     return VersionCheck(this) && XDRInterpretedFunction(this, objp, NULL);
 }
 
 template<XDRMode mode>
 bool
 XDRState<mode>::codeScript(JSScript **scriptp)
 {
     JSScript *script;
--- a/js/src/vm/Xdr.h
+++ b/js/src/vm/Xdr.h
@@ -288,17 +288,17 @@ class XDRState {
 
     bool codeChars(jschar *chars, size_t nchars);
 
     bool codeFunction(JSObject **objp);
     bool codeScript(JSScript **scriptp);
 
     void initScriptPrincipals(JSScript *script) {
         JS_ASSERT(mode == XDR_DECODE);
-        
+
         /* The origin principals must be normalized at this point. */
         JS_ASSERT_IF(principals, originPrincipals);
         JS_ASSERT(!script->principals);
         JS_ASSERT(!script->originPrincipals);
         if (principals) {
             script->principals = principals;
             JS_HoldPrincipals(principals);
         }
--- a/js/src/vm/make_unicode.py
+++ b/js/src/vm/make_unicode.py
@@ -62,25 +62,25 @@ public_domain = """
 """
 
 def read_unicode_data(unicode_file):
     """
         If you want to understand how this wonderful file format works checkout
           Unicode Standard Annex #44 - Unicode Character Database
           http://www.unicode.org/reports/tr44/
     """
-    
+
     reader = csv.reader(unicode_data, delimiter=';')
 
     while True:
         row = reader.next()
         name = row[1]
 
         # We need to expand the UAX #44 4.2.3 Code Point Range
-        if name.startswith('<') and name.endswith('First>'): 
+        if name.startswith('<') and name.endswith('First>'):
             next_row = reader.next()
 
             for i in range(int(row[0], 16), int(next_row[0], 16) + 1):
                 row[0] = i
                 row[1] = name[1:-8]
 
                 yield row
         else:
--- a/js/src/vprof/readme.txt
+++ b/js/src/vprof/readme.txt
@@ -35,35 +35,35 @@
 #
 # ***** END LICENSE BLOCK *****
 
 The two files vprof.h and vprof.cpp implement a simple value-profiling mechanism. By including these two files in avmplus (or any other project), you can value profile data as you wish (currently integers).
 
 Usage:
 #include "vprof.h"  // in the source file you want to use it
 
-_vprof (value); 
+_vprof (value);
 
 At the end of the execution, for each probe you'll get the data associated with the probe, such as:
 
 File                                        line    avg     [min : max] total       count
-..\..\pcre\pcre_valid_utf8.cpp  182 50222.75916 [0 :    104947] 4036955604  80381  
+..\..\pcre\pcre_valid_utf8.cpp  182 50222.75916 [0 :    104947] 4036955604  80381
 
 The probe is defined at line 182 of file pcre_vali_utf8.cpp. It was called 80381 times. The min value of the probe was 0 while its max was 10497 and its average was  50222.75916. The total sum of all values of the probe is 4036955604. Later, I plan to add more options on the spectrum of data among others.
 
 A few typical uses
 ------------------
 
 To see how many times a given function gets executed do:
 
 void f()
 {
     _vprof(1);
     ...
-} 
+}
 
 void f()
 {
         _vprof(1);
         ...
        if (...) {
            _vprof(1);
            ...
@@ -72,59 +72,59 @@ void f()
            ...
        }
 }
 
 Here are a few examples of using the value-profiling utility:
 
   _vprof (e);
     at the end of program execution, you'll get a dump of the source location of this probe,
-    its min, max, average, the total sum of all instances of e, and the total number of times this probe was called. 
+    its min, max, average, the total sum of all instances of e, and the total number of times this probe was called.
 
-  _vprof (x > 0); 
-    shows how many times and what percentage of the cases x was > 0, 
+  _vprof (x > 0);
+    shows how many times and what percentage of the cases x was > 0,
     that is the probablitiy that x > 0.
- 
- _vprof (n % 2 == 0); 
-    shows how many times n was an even number 
-    as well as th probablitiy of n being an even number. 
- 
- _hprof (n, 4, 1000, 5000, 5001, 10000); 
+
+ _vprof (n % 2 == 0);
+    shows how many times n was an even number
+    as well as th probablitiy of n being an even number.
+
+ _hprof (n, 4, 1000, 5000, 5001, 10000);
     gives you the histogram of n over the given 4 bucket boundaries:
-        # cases <  1000 
+        # cases <  1000
         # cases >= 1000 and < 5000
         # cases >= 5000 and < 5001
         # cases >= 5001 and < 10000
-        # cases >= 10000  
- 
- _nvprof ("event name", value); 
+        # cases >= 10000
+
+ _nvprof ("event name", value);
     all instances with the same name are merged
     so, you can call _vprof with the same event name at difference places
- 
- _vprof (e, myProbe);  
+
+ _vprof (e, myProbe);
     value profile e and call myProbe (void* vprofID) at the profiling point.
     inside the probe, the client has the predefined variables:
     _VAL, _COUNT, _SUM, _MIN, _MAX, and the general purpose registers
     _IVAR1, ..., IVAR4      general integer registrs
-    _I64VAR1, ..., I64VAR4  general integer64 registrs  
+    _I64VAR1, ..., I64VAR4  general integer64 registrs
     _DVAR1, ..., _DVAR4     general double registers
-    _GENPTR a generic pointer that can be used by the client 
+    _GENPTR a generic pointer that can be used by the client
     the number of registers can be changed in vprof.h
 
 Named Events
 ------------
-_nvprof ("event name", value);  
+_nvprof ("event name", value);
     all instances with the same name are merged
     so, you can call _vprof with the same event name at difference places
 
 
 Custom Probes
 --------------
 You can call your own custom probe at the profiling point.
-_vprof (v, myProbe);  
+_vprof (v, myProbe);
    value profile v and call myProbe (void* vprofID) at the profiling point
    inside the probe, the client has the predefined variables:
    _VAL, _COUNT, _SUM, _MIN, _MAX, and the general purpose registers
    _IVAR1, ..., IVAR4   general integer registrs
-   _I64VAR1, ..., I64VAR4 general integer64 registrs    
+   _I64VAR1, ..., I64VAR4 general integer64 registrs
    _DVAR1, ..., _DVAR4  general double registers
   the number of registers can be changed in vprof.h
-  _GENPTR a generic pointer that can be used for almost anything                
+  _GENPTR a generic pointer that can be used for almost anything
--- a/js/src/vprof/testVprofMT.c
+++ b/js/src/vprof/testVprofMT.c
@@ -15,17 +15,17 @@
  * The Original Code is Value-Profiling Utility.
  *
  * The Initial Developer of the Original Code is
  * Intel Corporation.
  * Portions created by the Initial Developer are Copyright (C) 2008
  * the Initial Developer. All Rights Reserved.
  *
  * Contributor(s):
- *   Mohammad R. Haghighat [mohammad.r.haghighat@intel.com] 
+ *   Mohammad R. Haghighat [mohammad.r.haghighat@intel.com]
  *
  * Alternatively, the contents of this file may be used under the terms of
  * either the GNU General Public License Version 2 or later (the "GPL"), or
  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  * in which case the provisions of the GPL or the LGPL are applicable instead
  * of those above. If you wish to allow use of your version of this file only
  * under the terms of either the GPL or the LGPL, and not to allow others to
  * use your version of this file under the terms of the MPL, indicate your
@@ -94,23 +94,23 @@ void sub(int val)
     //printf("sub %d done.\n", val);
 }
 
 HANDLE array[THREADS];
 
 static int run (void)
 {
     int i;
-    
+
     time_t start_time = time(0);
-    
+
     for (i = 0; i < THREADS; i++) {
         array[i] = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)sub, (LPVOID)i, 0, 0);
     }
-    
+
     for (i = 0; i < THREADS; i++) {
         WaitForSingleObject(array[i], INFINITE);
     }
 
     return 0;
 }
 
 int main ()
--- a/js/src/vprof/vprof.cpp
+++ b/js/src/vprof/vprof.cpp
@@ -15,17 +15,17 @@
  * The Original Code is Value-Profiling Utility.
  *
  * The Initial Developer of the Original Code is
  * Intel Corporation.
  * Portions created by the Initial Developer are Copyright (C) 2008
  * the Initial Developer. All Rights Reserved.
  *
  * Contributor(s):
- *   Mohammad R. Haghighat [mohammad.r.haghighat@intel.com] 
+ *   Mohammad R. Haghighat [mohammad.r.haghighat@intel.com]
  *
  * Alternatively, the contents of this file may be used under the terms of
  * either the GNU General Public License Version 2 or later (the "GPL"), or
  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  * in which case the provisions of the GPL or the LGPL are applicable instead
  * of those above. If you wish to allow use of your version of this file only
  * under the terms of either the GPL or the LGPL, and not to allow others to
  * use your version of this file under the terms of the MPL, indicate your
@@ -73,17 +73,17 @@
 #if THREADED
 #define DO_LOCK(lock) Lock(lock); {
 #define DO_UNLOCK(lock) }; Unlock(lock)
 #else
 #define DO_LOCK(lock) { (void)(lock);
 #define DO_UNLOCK(lock) }
 #endif
 
-#if THREAD_SAFE  
+#if THREAD_SAFE
 #define LOCK(lock) DO_LOCK(lock)
 #define UNLOCK(lock) DO_UNLOCK(lock)
 #else
 #define LOCK(lock) { (void)(lock);
 #define UNLOCK(lock) }
 #endif
 
 static entry* entries = NULL;
@@ -116,17 +116,17 @@ inline static entry* reverse (entry* s)
     entry_t e, n, p;
 
     p = NULL;
     for (e = s; e; e = n) {
         n = e->next;
         e->next = p;
         p = e;
     }
-    
+
     return p;
 }
 
 static char* f (double d)
 {
     static char s[80];
     char* p;
     sprintf_s (s, sizeof(s), "%lf", d);
@@ -143,21 +143,21 @@ static char* f (double d)
 static void dumpProfile (void)
 {
     entry_t e;
 
     entries = reverse(entries);
     vprof_printf ("event avg [min : max] total count\n");
     for (e = entries; e; e = e->next) {
         if (e->count == 0) continue;  // ignore entries with zero count.
-        vprof_printf ("%s", e->file); 
+        vprof_printf ("%s", e->file);
         if (e->line >= 0) {
             vprof_printf (":%d", e->line);
-        } 
-        vprof_printf (" %s [%lld : %lld] %lld %lld ", 
+        }
+        vprof_printf (" %s [%lld : %lld] %lld %lld ",
                 f(((double)e->sum)/((double)e->count)), (long long int)e->min, (long long int)e->max, (long long int)e->sum, (long long int)e->count);
         if (e->h) {
             int j = MAXINT;
             for (j = 0; j < e->h->nbins; j ++) {
                 vprof_printf ("(%lld < %lld) ", (long long int)e->h->count[j], (long long int)e->h->lb[j]);
             }
             vprof_printf ("(%lld >= %lld) ", (long long int)e->h->count[e->h->nbins], (long long int)e->h->lb[e->h->nbins-1]);
         }
@@ -280,17 +280,17 @@ int initHistProfile(void** id, char* fil
             notInitialized = false;
         }
 
         if (e == NULL) {
             e = findEntry (file, line);
             if (e) {
                 *id = e;
             }
-        } 
+        }
 
         if (e == NULL) {
             va_list va;
             hist_t h;
             int b, n, s;
             int64_t* lb;
 
             e = (entry_t) malloc (sizeof(entry));
--- a/js/src/vprof/vprof.h
+++ b/js/src/vprof/vprof.h
@@ -15,17 +15,17 @@
  * The Original Code is Value-Profiling Utility.
  *
  * The Initial Developer of the Original Code is
  * Intel Corporation.
  * Portions created by the Initial Developer are Copyright (C) 2008
  * the Initial Developer. All Rights Reserved.
  *
  * Contributor(s):
- *   Mohammad R. Haghighat [mohammad.r.haghighat@intel.com] 
+ *   Mohammad R. Haghighat [mohammad.r.haghighat@intel.com]
  *
  * Alternatively, the contents of this file may be used under the terms of
  * either the GNU General Public License Version 2 or later (the "GPL"), or
  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  * in which case the provisions of the GPL or the LGPL are applicable instead
  * of those above. If you wish to allow use of your version of this file only
  * under the terms of either the GPL or the LGPL, and not to allow others to
  * use your version of this file under the terms of the MPL, indicate your
@@ -36,46 +36,46 @@
  *
  * ***** END LICENSE BLOCK ***** */
 
 //
 //  Here are a few examples of using the value-profiling utility:
 //
 //  _vprof (e);
 //    at the end of program execution, you'll get a dump of the source location of this probe,
-//    its min, max, average, the total sum of all instances of e, and the total number of times this probe was called. 
+//    its min, max, average, the total sum of all instances of e, and the total number of times this probe was called.
 //
-//  _vprof (x > 0); 
-//    shows how many times and what percentage of the cases x was > 0, 
+//  _vprof (x > 0);
+//    shows how many times and what percentage of the cases x was > 0,
 //    that is the probablitiy that x > 0.
-// 
-// _vprof (n % 2 == 0); 
-//    shows how many times n was an even number 
-//    as well as th probablitiy of n being an even number. 
-// 
-// _hprof (n, 4, 1000, 5000, 5001, 10000); 
+//
+// _vprof (n % 2 == 0);
+//    shows how many times n was an even number
+//    as well as th probablitiy of n being an even number.
+//
+// _hprof (n, 4, 1000, 5000, 5001, 10000);
 //    gives you the histogram of n over the given 4 bucket boundaries:
-//        # cases <  1000 
+//        # cases <  1000
 //        # cases >= 1000 and < 5000
 //        # cases >= 5000 and < 5001
 //        # cases >= 5001 and < 10000
-//        # cases >= 10000  
-// 
-// _nvprof ("event name", value);   
+//        # cases >= 10000
+//
+// _nvprof ("event name", value);
 //    all instances with the same name are merged
 //    so, you can call _vprof with the same event name at difference places
-// 
-// _vprof (e, myProbe);  
+//
+// _vprof (e, myProbe);
 //    value profile e and call myProbe (void* vprofID) at the profiling point.
 //    inside the probe, the client has the predefined variables:
 //    _VAL, _COUNT, _SUM, _MIN, _MAX, and the general purpose registers
 //    _IVAR1, ..., IVAR4      general integer registrs
-//    _I64VAR1, ..., I64VAR4  general integer64 registrs    
+//    _I64VAR1, ..., I64VAR4  general integer64 registrs
 //    _DVAR1, ..., _DVAR4     general double registers
-//    _GENPTR a generic pointer that can be used by the client 
+//    _GENPTR a generic pointer that can be used by the client
 //    the number of registers can be changed in vprof.h
 //
 
 #ifndef __VPROF__
 #define __VPROF__
 //
 // If the application for which you want to use vprof is threaded, THREADED must be defined as 1, otherwise define it as 0
 //
@@ -108,17 +108,17 @@ extern "C" {
 int initValueProfile(void** id, char* file, int line, ...);
 int profileValue(void* id, int64_t value);
 int initHistProfile(void** id, char* file, int line, int nbins, ...);
 int histValue(void* id, int64_t value);
 uint64_t readTimestampCounter();
 
 #ifdef __cplusplus
 }
-#endif 
+#endif
 
 //#define DOPROF
 
 #ifndef DOPROF
 #define _nvprof(e,v)
 #ifndef VMCFG_SYMBIAN
 #define _vprof(v,...)
 #define _hprof(v,n,...)
@@ -134,17 +134,17 @@ uint64_t readTimestampCounter();
 #endif // ! VMCFG_SYMBIAN
 #else
 
 // Historical/compatibility note:
 // The macros below were originally written using conditional expressions, not if/else.  The original author
 // said that this was done to allow _vprof and _nvprof to be used in an expression context, but the old code
 // had already wrapped the macro bodies in { }, so it is not clear how this could have worked.  At present,
 // the profiling macros must appear in a statement context only.
- 
+
 #define _vprof(v,...) \
 do { \
     static void* id = 0; \
     if (id == 0) \
         initValueProfile(&id, __FILE__, __LINE__, ##__VA_ARGS__, NULL); \
     profileValue(id, (int64_t) (v)); \
 } while (0)
 
@@ -229,23 +229,23 @@ do { \
 #define _jhprof(id,v) \
     histValue((id), (int64_t) (v))
 
 #endif
 
 #define NUM_EVARS 4
 
 enum {
-    LOCK_IS_FREE = 0, 
+    LOCK_IS_FREE = 0,
     LOCK_IS_TAKEN = 1
 };
 
 extern
 #ifdef __cplusplus
-"C" 
+"C"
 #endif
 long _InterlockedCompareExchange (
    long volatile * Destination,
    long Exchange,
    long Comperand
 );
 
 typedef struct hist hist;
new file mode 100644
--- /dev/null
+++ b/js/xpconnect/crashtests/720305-1.html
@@ -0,0 +1,8 @@
+<!DOCTYPE html>
+<script>
+
+var c = document.getElementsByClassName("x");
+Object.defineProperty(c, "length", {set: void 0});
+Array.prototype.shift.call(c);
+
+</script>
--- a/js/xpconnect/crashtests/crashtests.list
+++ b/js/xpconnect/crashtests/crashtests.list
@@ -30,10 +30,11 @@ load 582649.html
 load 601284-1.html
 load 603146-1.html
 load 603858-1.html
 load 608963.html
 load 616930-1.html
 load 639737-1.html
 load 648206-1.html
 load 705875.html
+load 720305-1.html
 load 723465.html
 load 754311.html
--- a/js/xpconnect/src/XPCWrappedNativeJSOps.cpp
+++ b/js/xpconnect/src/XPCWrappedNativeJSOps.cpp
@@ -610,18 +610,23 @@ XPC_WN_Shared_Enumerate(JSContext *cx, J
 }
 
 /***************************************************************************/
 
 #ifdef DEBUG_slimwrappers
 static PRUint32 sFinalizedSlimWrappers;
 #endif
 
+enum WNHelperType {
+    WN_NOHELPER,
+    WN_HELPER
+};
+
 static void
-XPC_WN_NoHelper_Finalize(js::FreeOp *fop, JSObject *obj)
+WrappedNativeFinalize(js::FreeOp *fop, JSObject *obj, WNHelperType helperType)
 {
     js::Class* clazz = js::GetObjectClass(obj);
     if (clazz->flags & JSCLASS_DOM_GLOBAL) {
         mozilla::dom::DestroyProtoOrIfaceCache(obj);
     }
     nsISupports* p = static_cast<nsISupports*>(xpc_GetJSPrivate(obj));
     if (!p)
         return;
@@ -630,24 +635,31 @@ XPC_WN_NoHelper_Finalize(js::FreeOp *fop
         SLIM_LOG(("----- %i finalized slim wrapper (%p, %p)\n",
                   ++sFinalizedSlimWrappers, obj, p));
 
         nsWrapperCache* cache;
         CallQueryInterface(p, &cache);
         cache->ClearWrapper();
 
         XPCJSRuntime *rt = nsXPConnect::GetRuntimeInstance();
-        if(rt)
-            rt->DeferredRelease(p);
-        else
-            NS_RELEASE(p);
+        MOZ_ASSERT(rt, "XPCJSRuntime should exist during a GC.");
+        rt->DeferredRelease(p);
         return;
     }
 
-    static_cast<XPCWrappedNative*>(p)->FlatJSObjectFinalized();
+    XPCWrappedNative* wrapper = static_cast<XPCWrappedNative*>(p);
+    if (helperType == WN_HELPER)
+        wrapper->GetScriptableCallback()->Finalize(wrapper, js::CastToJSFreeOp(fop), obj);
+    wrapper->FlatJSObjectFinalized();
+}
+
+static void
+XPC_WN_NoHelper_Finalize(js::FreeOp *fop, JSObject *obj)
+{
+    WrappedNativeFinalize(fop, obj, WN_NOHELPER);
 }
 
 static void
 TraceScopeJSObjects(JSTracer *trc, XPCWrappedNativeScope* scope)
 {
     scope->TraceSelf(trc);
 }
 
@@ -1035,38 +1047,17 @@ XPC_WN_Helper_HasInstance(JSContext *cx,
     HasInstance(wrapper, cx, obj, *valp, &retval2, &retval);
     *bp = retval2;
     POST_HELPER_STUB
 }
 
 static void
 XPC_WN_Helper_Finalize(js::FreeOp *fop, JSObject *obj)
 {
-    js::Class* clazz = js::GetObjectClass(obj);
-    if (clazz->flags & JSCLASS_DOM_GLOBAL) {
-        mozilla::dom::DestroyProtoOrIfaceCache(obj);
-    }
-    nsISupports* p = static_cast<nsISupports*>(xpc_GetJSPrivate(obj));
-    if (IS_SLIM_WRAPPER(obj)) {
-        SLIM_LOG(("----- %i finalized slim wrapper (%p, %p)\n",
-                  ++sFinalizedSlimWrappers, obj, p));
-
-        nsWrapperCache* cache;
-        CallQueryInterface(p, &cache);
-        cache->ClearWrapper();
-        NS_RELEASE(p);
-        return;
-    }
-
-    XPCWrappedNative* wrapper = (XPCWrappedNative*)p;
-    if (!wrapper)
-        return;
-
-    wrapper->GetScriptableCallback()->Finalize(wrapper, js::CastToJSFreeOp(fop), obj);
-    wrapper->FlatJSObjectFinalized();
+    WrappedNativeFinalize(fop, obj, WN_HELPER);
 }
 
 static JSBool
 XPC_WN_Helper_NewResolve(JSContext *cx, JSObject *obj, jsid id, unsigned flags,
                          JSObject **objp)
 {
     nsresult rv = NS_OK;
     bool retval = true;
--- a/layout/svg/base/src/nsSVGInnerSVGFrame.cpp
+++ b/layout/svg/base/src/nsSVGInnerSVGFrame.cpp
@@ -150,30 +150,28 @@ nsSVGInnerSVGFrame::NotifySVGChanged(PRU
          svg->mLengthAttributes[nsSVGSVGElement::Y].IsPercentage() ||
          (svg->HasViewBox() &&
           (svg->mLengthAttributes[nsSVGSVGElement::WIDTH].IsPercentage() ||
            svg->mLengthAttributes[nsSVGSVGElement::HEIGHT].IsPercentage())))) {
     
       aFlags |= TRANSFORM_CHANGED;
     }
 
-    // XXX We could clear the COORD_CONTEXT_CHANGED flag in some circumstances
-    // if we have a non-percentage 'width' AND 'height, or if we have a 'viewBox'
-    // rect. This is because, when we have a viewBox rect, the viewBox rect
-    // is the coordinate context for our children, and it isn't changing.
-    // Percentage lengths on our children will continue to resolve to the
-    // same number of user units because they're relative to our viewBox rect. The
-    // same is true if we have a non-percentage width and height and don't have a
-    // viewBox. We (the <svg>) establish the coordinate context for our children. Our
-    // children don't care about changes to our parent coordinate context unless that
-    // change results in a change to the coordinate context that _we_ establish. Hence
-    // we can (should, really) stop propagating COORD_CONTEXT_CHANGED in these cases.
-    // We'd actually need to check that we have a viewBox rect and not just
-    // that viewBox is set, since it could be set to none.
-    // Take care not to break the testcase for bug 394463 when implementing this
+    if (svg->HasViewBox() ||
+        (!svg->mLengthAttributes[nsSVGSVGElement::WIDTH].IsPercentage() &&
+         !svg->mLengthAttributes[nsSVGSVGElement::HEIGHT].IsPercentage())) {
+      // Remove COORD_CONTEXT_CHANGED, since we establish the coordinate
+      // context for our descendants and this notification won't change its
+      // dimensions:
+      aFlags &= ~COORD_CONTEXT_CHANGED;
+
+      if (!(aFlags & ~DO_NOT_NOTIFY_RENDERING_OBSERVERS)) {
+        return; // No notification flags left
+      }
+    }
   }
 
   if (aFlags & TRANSFORM_CHANGED) {
     // make sure our cached transform matrix gets (lazily) updated
     mCanvasTM = nsnull;
   }
 
   nsSVGInnerSVGFrameBase::NotifySVGChanged(aFlags);
--- a/layout/svg/base/src/nsSVGUseFrame.cpp
+++ b/layout/svg/base/src/nsSVGUseFrame.cpp
@@ -220,16 +220,20 @@ nsSVGUseFrame::NotifySVGChanged(PRUint32
     // percentage 'x' or 'y'
     nsSVGUseElement *use = static_cast<nsSVGUseElement*>(mContent);
     if (use->mLengthAttributes[nsSVGUseElement::X].IsPercentage() ||
         use->mLengthAttributes[nsSVGUseElement::Y].IsPercentage()) {
       aFlags |= TRANSFORM_CHANGED;
     }
   }
 
+  // We don't remove the TRANSFORM_CHANGED flag here if we have a viewBox or
+  // non-percentage width/height, since if they're set then they are cloned to
+  // an anonymous child <svg>, and its nsSVGInnerSVGFrame will do that.
+
   nsSVGUseFrameBase::NotifySVGChanged(aFlags);
 }
 
 //----------------------------------------------------------------------
 // nsIAnonymousContentCreator methods:
 
 nsresult
 nsSVGUseFrame::CreateAnonymousContent(nsTArray<ContentInfo>& aElements)
--- a/netwerk/protocol/http/nsHttpHandler.cpp
+++ b/netwerk/protocol/http/nsHttpHandler.cpp
@@ -649,17 +649,17 @@ nsHttpHandler::BuildUserAgent()
     mUserAgent += ' ';
 
     // Application comment
     mUserAgent += '(';
 #ifndef UA_SPARE_PLATFORM
     mUserAgent += mPlatform;
     mUserAgent.AppendLiteral("; ");
 #endif
-#ifdef ANDROID
+#if defined(ANDROID) || defined(MOZ_PLATFORM_MAEMO)
     if (!mCompatDevice.IsEmpty()) {
         mUserAgent += mCompatDevice;
         mUserAgent.AppendLiteral("; ");
     }
 #else
     mUserAgent += mOscpu;
     mUserAgent.AppendLiteral("; ");
 #endif
@@ -707,17 +707,17 @@ nsHttpHandler::InitUserAgentComponents()
     "Maemo"
 #elif defined(MOZ_X11)
     "X11"
 #else
     "?"
 #endif
     );
 
-#if defined(ANDROID)
+#if defined(ANDROID) || defined(MOZ_PLATFORM_MAEMO)
     nsCOMPtr<nsIPropertyBag2> infoService = do_GetService("@mozilla.org/system-info;1");
     NS_ASSERTION(infoService, "Could not find a system info service");
 
     bool isTablet = false;
     infoService->GetPropertyAsBool(NS_LITERAL_STRING("tablet"), &isTablet);
     if (isTablet)
         mCompatDevice.AssignLiteral("Tablet");
     else
--- a/xpcom/base/nsSystemInfo.cpp
+++ b/xpcom/base/nsSystemInfo.cpp
@@ -157,24 +157,38 @@ nsSystemInfo::Init()
 #endif
     if (fp) {
       while ((read = getline(&line, &len, fp)) != -1) {
         if (line) {
           if (strstr(line, "RX-51")) {
             SetPropertyAsACString(NS_LITERAL_STRING("device"), NS_LITERAL_CSTRING("Nokia N900"));
             SetPropertyAsACString(NS_LITERAL_STRING("manufacturer"), NS_LITERAL_CSTRING("Nokia"));
             SetPropertyAsACString(NS_LITERAL_STRING("hardware"), NS_LITERAL_CSTRING("RX-51"));
+            SetPropertyAsBool(NS_LITERAL_STRING("tablet"), false);
             break;
           } else if (strstr(line, "RX-44") ||
                      strstr(line, "RX-48") ||
                      strstr(line, "RX-32") ) {
             /* not as accurate as we can be, but these devices are deprecated */
             SetPropertyAsACString(NS_LITERAL_STRING("device"), NS_LITERAL_CSTRING("Nokia N8xx"));
             SetPropertyAsACString(NS_LITERAL_STRING("manufacturer"), NS_LITERAL_CSTRING("Nokia"));
             SetPropertyAsACString(NS_LITERAL_STRING("hardware"), NS_LITERAL_CSTRING("N8xx"));
+            SetPropertyAsBool(NS_LITERAL_STRING("tablet"), false);
+            break;
+          } else if (strstr(line, "RM-680")) {
+            SetPropertyAsACString(NS_LITERAL_STRING("device"), NS_LITERAL_CSTRING("Nokia N950"));
+            SetPropertyAsACString(NS_LITERAL_STRING("manufacturer"), NS_LITERAL_CSTRING("Nokia"));
+            SetPropertyAsACString(NS_LITERAL_STRING("hardware"), NS_LITERAL_CSTRING("N9xx"));
+            SetPropertyAsBool(NS_LITERAL_STRING("tablet"), false);
+            break;
+          } else if (strstr(line, "RM-696")) {
+            SetPropertyAsACString(NS_LITERAL_STRING("device"), NS_LITERAL_CSTRING("Nokia N9"));
+            SetPropertyAsACString(NS_LITERAL_STRING("manufacturer"), NS_LITERAL_CSTRING("Nokia"));
+            SetPropertyAsACString(NS_LITERAL_STRING("hardware"), NS_LITERAL_CSTRING("N9xx"));
+            SetPropertyAsBool(NS_LITERAL_STRING("tablet"), false);
             break;
           }
         }
       }
       if (line)
         free(line);
 #if MOZ_PLATFORM_MAEMO > 5
       pclose(fp);