Bug 673499 - remove some trailing whitespace from js/src. r=jorendorff
authorTom Schuster <evilpies@gmail.com>
Sat, 19 May 2012 21:56:17 +0200
changeset 98500 c80dde3faa3d838f28b16b4d21be72cc09e00ca3
parent 98499 932a19f737d9e82e3438cb3a71b490aa256e2cc1
child 98501 20b27f266d734a8a6cacf69ff46b6816bc9e5a75
push idunknown
push userunknown
push dateunknown
reviewersjorendorff
bugs673499
milestone15.0a1
Bug 673499 - remove some trailing whitespace from js/src. r=jorendorff
js/src/ETWProvider.man
js/src/Makefile.in
js/src/MemoryMetrics.cpp
js/src/README.html
js/src/aclocal.m4
js/src/builtin/RegExp.h
js/src/configure.in
js/src/frontend/BytecodeEmitter.h
js/src/frontend/ParseNode.cpp
js/src/frontend/SemanticAnalysis.cpp
js/src/frontend/TreeContext.h
js/src/javascript-trace.d
js/src/js-config.in
js/src/jsanalyze.cpp
js/src/jsanalyze.h
js/src/jsapi-tests/testAddPropertyPropcache.cpp
js/src/jsapi-tests/testCloneScript.cpp
js/src/jsapi-tests/testDebugger.cpp
js/src/jsapi-tests/testResolveRecursion.cpp
js/src/jsapi-tests/testSlowScript.cpp
js/src/jsapi-tests/testVersion.cpp
js/src/jsapi-tests/testXDR.cpp
js/src/jsapi.cpp
js/src/jsapi.h
js/src/jsarray.cpp
js/src/jsatom.cpp
js/src/jsatom.h
js/src/jsatom.tbl
js/src/jsatominlines.h
js/src/jscntxt.cpp
js/src/jscntxtinlines.h
js/src/jscompartment.cpp
js/src/jsdate.cpp
js/src/jsdbgapi.cpp
js/src/jsdtoa.h
js/src/jsfriendapi.cpp
js/src/jsfun.cpp
js/src/jsfun.h
js/src/jsgc.cpp
js/src/jsinfer.cpp
js/src/jsinterp.cpp
js/src/jsinterp.h
js/src/jsinterpinlines.h
js/src/jslibmath.h
js/src/jsmath.cpp
js/src/jsnativestack.cpp
js/src/jsnum.cpp
js/src/jsobj.cpp
js/src/jsopcode.cpp
js/src/jspropertycache.h
js/src/jspropertytree.h
js/src/jsproxy.cpp
js/src/jsreflect.cpp
js/src/jsreops.tbl
js/src/jsscope.cpp
js/src/jsscope.h
js/src/jsscript.cpp
js/src/jsscript.h
js/src/jsshell.msg
js/src/jsstr.cpp
js/src/jsstr.h
js/src/jstypedarray.h
js/src/jsweakmap.cpp
js/src/jswin64.asm
js/src/jswrapper.cpp
js/src/methodjit/BaseAssembler.h
js/src/methodjit/Compiler.cpp
js/src/methodjit/Compiler.h
js/src/methodjit/FastArithmetic.cpp
js/src/methodjit/FastBuiltins.cpp
js/src/methodjit/FastOps.cpp
js/src/methodjit/FrameState-inl.h
js/src/methodjit/FrameState.cpp
js/src/methodjit/FrameState.h
js/src/methodjit/ICLabels.h
js/src/methodjit/ICRepatcher.h
js/src/methodjit/InvokeHelpers.cpp
js/src/methodjit/MethodJIT.cpp
js/src/methodjit/MethodJIT.h
js/src/methodjit/MonoIC.cpp
js/src/methodjit/NunboxAssembler.h
js/src/methodjit/PolyIC.h
js/src/methodjit/PunboxAssembler.h
js/src/methodjit/Retcon.cpp
js/src/methodjit/Retcon.h
js/src/methodjit/StubCalls.cpp
js/src/methodjit/StubCalls.h
js/src/methodjit/StubCompiler.cpp
js/src/methodjit/TrampolineCompiler.cpp
js/src/methodjit/TrampolineCompiler.h
js/src/methodjit/TrampolineMIPS.cpp
js/src/methodjit/TrampolineMasmX64.asm
js/src/methodjit/TrampolineSUNWX86.s
js/src/methodjit/TrampolineSparc.s
js/src/methodjit/TypedArrayIC.h
js/src/shell/jsheaptools.cpp
js/src/shell/jsoptparse.cpp
js/src/shell/jsoptparse.h
js/src/shell/jsworkers.cpp
js/src/vm/Debugger.cpp
js/src/vm/RegExpStatics-inl.h
js/src/vm/Xdr.cpp
js/src/vm/Xdr.h
js/src/vm/make_unicode.py
js/src/vprof/readme.txt
js/src/vprof/testVprofMT.c
js/src/vprof/vprof.cpp
js/src/vprof/vprof.h
--- a/js/src/ETWProvider.man
+++ b/js/src/ETWProvider.man
@@ -19,17 +19,17 @@
           <event symbol="EvtExecuteStart" value="1001" version="1"
                  channel="MozillaChannel" level="win:Informational"
                  template="CodeLocationTemplate" task="Execution" opcode="ExecuteStart"
                  keywords="SampleKeyword" message="$(string.MozillaSpiderMonkey.ExecuteStart.message)"/>
           <event symbol="EvtExecuteDone" value="1002" version="1"
                  channel="MozillaChannel" level="win:Informational"
                  template="CodeLocationTemplate" task="Execution" opcode="ExecuteStop"
                  keywords="SampleKeyword" message="$(string.MozillaSpiderMonkey.ExecuteDone.message)"/>
-          
+
           <event symbol="EvtScriptCompileBegin" value="1003" version="1"
                  channel="MozillaChannel" level="win:Informational"
                  template="CodeLocationTemplate" task="Execution" opcode="CompileBegin"
                  keywords="SampleKeyword" message="$(string.MozillaSpiderMonkey.ScriptCompileBegin.message)"/>
           <event symbol="EvtScriptCompileEnd" value="1004" version="1"
                  channel="MozillaChannel" level="win:Informational"
                  template="CodeLocationTemplate" task="Execution" opcode="CompileEnd"
                  keywords="SampleKeyword" message="$(string.MozillaSpiderMonkey.ScriptCompileEnd.message)"/>
@@ -56,17 +56,17 @@
           <event symbol="EvtObjectCreate" value="1007" version="1"
                  channel="MozillaChannel" level="win:Verbose"
                  template="ObjectCreateTemplate" task="Allocation" opcode="ObjectCreate"
                  keywords="SampleKeyword" message="$(string.SampleProvider.SampleEvent.message)"/>
           <event symbol="EvtObjectFinalize" value="1008" version="1"
                  channel="MozillaChannel" level="win:Verbose"
                  template="ObjectFinalizeTemplate" task="Allocation" opcode="ObjectFinalize"
                  keywords="SampleKeyword" message="$(string.SampleProvider.SampleEvent.message)"/>
-          
+
           <event symbol="EvtStringCreate" value="1009" version="1"
                  channel="MozillaChannel" level="win:Verbose"
                  template="StringCreateTemplate" task="Allocation" opcode="StringCreate"
                  keywords="SampleKeyword" message="$(string.SampleProvider.SampleEvent.message)"/>
           <event symbol="EvtStringFinalize" value="1010" version="1"
                  channel="MozillaChannel" level="win:Verbose"
                  template="StringFinalizeTemplate" task="Allocation" opcode="StringFinalize"
                  keywords="SampleKeyword" message="$(string.SampleProvider.SampleEvent.message)"/>
@@ -89,17 +89,17 @@
           <event symbol="EvtGCStartMarkPhase" value="1014" version="1"
                  channel="MozillaChannel" level="win:Informational"
                  template="VoidTemplate" task="Allocation" opcode="GCMarkStart"
                  keywords="SampleKeyword" message="$(string.SampleProvider.SampleEvent.message)"/>
           <event symbol="EvtGCEndMarkPhase" value="1015" version="1"
                  channel="MozillaChannel" level="win:Informational"
                  template="VoidTemplate" task="Allocation" opcode="GCMarkEnd"
                  keywords="SampleKeyword" message="$(string.SampleProvider.SampleEvent.message)"/>
-                    
+
           <event symbol="EvtGCStartSweepPhase" value="1016" version="1"
                  channel="MozillaChannel" level="win:Informational"
                  template="VoidTemplate" task="Allocation" opcode="GCSweepStart"
                  keywords="SampleKeyword" message="$(string.SampleProvider.SampleEvent.message)"/>
           <event symbol="EvtGCEndSweepPhase" value="1017" version="1"
                  channel="MozillaChannel" level="win:Informational"
                  template="VoidTemplate" task="Allocation" opcode="GCSweepEnd"
                  keywords="SampleKeyword" message="$(string.SampleProvider.SampleEvent.message)"/>
@@ -168,33 +168,33 @@
           <opcode name="GCMarkEnd" symbol="OpGCMarkEnd" value="27"/>
           <opcode name="GCSweepStart" symbol="OpGCSweepStart" value="28"/>
           <opcode name="GCSweepEnd" symbol="OpGCSweepEnd" value="29"/>
           <opcode name="AcquireMemory" symbol="OpAcquireMemory" value="30"/>
           <opcode name="ReleaseMemory" symbol="OpReleaseMemory" value="31"/>
           <opcode name="ResizeHeap" symbol="OpResizeHeap" value="32"/>
           <opcode name="CustomMark" symbol="OpCustomMark" value="33"/>
         </opcodes>
-        
+
         <channels>
           <channel name="MozillaChannel" chid="MozillaPerformanceReportingChannel"
                    symbol="MOZILLA_PERFORMANCE_REPORTING_CHANNEL" type="Analytic"
                    enabled="true"/>
         </channels>
 
         <keywords>
           <keyword name="SampleKeyword" symbol="KwSample" mask="0x1"/>
         </keywords>
-        
+
         <templates>
           <template tid="CodeLocationTemplate">
             <data name="FileName" inType="win:AnsiString" outType="xs:string"/>
             <data name="LineNumber" inType="win:Int32" outType="xs:int"/>
           </template>
-          
+
           <template tid="ObjectCreateTemplate">
             <data name="FileName" inType="win:AnsiString" outType="xs:string"/>
             <data name="LineNumber" inType="win:Int32" outType="xs:int"/>
             <data name="ClassName" inType="win:AnsiString" outType="xs:string"/>
             <data name="Address" inType="win:Int64" outType="xs:long"/>
             <data name="Size" inType="win:Int64" outType="xs:long"/>
           </template>
 
--- 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/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/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;