Bug 470791 - Remove all users of the long-obsolete JSLL_* macros. r=jimb
authorJeff Walden <jwalden@mit.edu>
Thu, 09 Jun 2011 01:13:03 -0700
changeset 71366 5da430ecfdd758083ba270676557c8f058becb24
parent 71365 ce077af8195c82557525c5b4aada944f4add9629
child 71367 159fedddb24cabf3658ab283066d76d1dbdaa5f8
push idunknown
push userunknown
push dateunknown
reviewersjimb
bugs470791
milestone7.0a1
Bug 470791 - Remove all users of the long-obsolete JSLL_* macros. r=jimb
js/jsd/jsd_step.c
js/src/Makefile.in
js/src/jscntxt.h
js/src/jscompat.h
js/src/jslong.h
js/src/jsmath.cpp
js/src/jsprf.cpp
js/src/prmjtime.cpp
js/src/prmjtime.h
--- a/js/jsd/jsd_step.c
+++ b/js/jsd/jsd_step.c
@@ -145,61 +145,57 @@ JSBool
             if (JSD_IS_PROFILE_ENABLED(jsdc, jsdscript))
             {
                 JSDProfileData *pdata;
                 pdata = jsd_GetScriptProfileData (jsdc, jsdscript);
                 if (pdata)
                 {
                     if (before)
                     {
-                        if (JSLL_IS_ZERO(pdata->lastCallStart))
+                        if (!pdata->lastCallStart)
                         {
                             int64 now;
                             JSDProfileData *callerpdata;
                             
                             /* Get the time just the once, for consistency. */
                             now = JS_Now();
                             /* This contains a pointer to the profile data for
                              * the caller of this function. */
                             callerpdata = jsdc->callingFunctionPData;
                             if (callerpdata)
                             {
                                 int64 ll_delta;
                                 pdata->caller = callerpdata;
                                 /* We need to 'stop' the timer for the caller.
                                  * Use time since last return if appropriate. */
-                                if (JSLL_IS_ZERO(jsdc->lastReturnTime))
-                                {
-                                    JSLL_SUB(ll_delta, now, callerpdata->lastCallStart);
-                                } else {
-                                    JSLL_SUB(ll_delta, now, jsdc->lastReturnTime);
-                                }
-                                JSLL_ADD(callerpdata->runningTime, callerpdata->runningTime, ll_delta);
+                                ll_delta = jsdc->lastReturnTime
+                                           ? now - jsdc->lastReturnTime
+                                           : now - callerpdata->lastCallStart;
+                                callerpdata->runningTime += ll_delta;
                             }
                             /* We're the new current function, and no return
                              * has happened yet. */
                             jsdc->callingFunctionPData = pdata;
                             jsdc->lastReturnTime = 0;
                             /* This function has no running time (just been
                              * called!), and we'll need the call start time. */
                             pdata->runningTime = 0;
                             pdata->lastCallStart = now;
                         } else {
                             if (++pdata->recurseDepth > pdata->maxRecurseDepth)
                                 pdata->maxRecurseDepth = pdata->recurseDepth;
                         }
                         /* make sure we're called for the return too. */
                         hookresult = JS_TRUE;
-                    } else if (!pdata->recurseDepth &&
-                               !JSLL_IS_ZERO(pdata->lastCallStart)) {
+                    } else if (!pdata->recurseDepth && pdata->lastCallStart) {
                         int64 now, ll_delta;
                         jsdouble delta;
                         now = JS_Now();
-                        JSLL_SUB(ll_delta, now, pdata->lastCallStart);
-                        JSLL_L2D(delta, ll_delta);
+                        ll_delta = now - pdata->lastCallStart;
+                        delta = (JSFloat64) ll_delta;
                         delta /= 1000.0;
                         pdata->totalExecutionTime += delta;
                         /* minExecutionTime starts as 0, so we need to overwrite
                          * it on the first call always. */
                         if ((0 == pdata->callCount) ||
                             delta < pdata->minExecutionTime)
                         {
                             pdata->minExecutionTime = delta;
@@ -207,23 +203,23 @@ JSBool
                         if (delta > pdata->maxExecutionTime)
                             pdata->maxExecutionTime = delta;
                         
                         /* If we last returned from a function (as opposed to
                          * having last entered this function), we need to inc.
                          * the running total by the time delta since the last
                          * return, and use the running total instead of the
                          * delta calculated above. */
-                        if (!JSLL_IS_ZERO(jsdc->lastReturnTime))
+                        if (jsdc->lastReturnTime)
                         {
                             /* Add last chunk to running time, and use total
                              * running time as 'delta'. */
-                            JSLL_SUB(ll_delta, now, jsdc->lastReturnTime);
-                            JSLL_ADD(pdata->runningTime, pdata->runningTime, ll_delta);
-                            JSLL_L2D(delta, pdata->runningTime);
+                            ll_delta = now - jsdc->lastReturnTime;
+                            pdata->runningTime += ll_delta;
+                            delta = (JSFloat64) pdata->runningTime;
                             delta /= 1000.0;
                         }
                         
                         pdata->totalOwnExecutionTime += delta;
                         /* See minExecutionTime comment above. */
                         if ((0 == pdata->callCount) ||
                             delta < pdata->minOwnExecutionTime)
                         {
--- a/js/src/Makefile.in
+++ b/js/src/Makefile.in
@@ -216,17 +216,16 @@ INSTALLED_HEADERS = \
 		jsgcchunk.h \
 		jsgcstats.h \
 		jscompartment.h \
 		jshash.h \
 		jsinterp.h \
 		jsinttypes.h \
 		jsiter.h \
 		jslock.h \
-		jslong.h \
 		jsobj.h \
 		json.h \
 		jsopcode.tbl \
 		jsopcode.h \
 		jsotypes.h \
 		jsparse.h \
 		jsproxy.h \
 		jsprf.h \
--- a/js/src/jscntxt.h
+++ b/js/src/jscntxt.h
@@ -43,17 +43,16 @@
 /*
  * JS execution context.
  */
 #include <string.h>
 
 #include "jsprvtd.h"
 #include "jsarena.h"
 #include "jsclist.h"
-#include "jslong.h"
 #include "jsatom.h"
 #include "jsdhash.h"
 #include "jsfun.h"
 #include "jsgc.h"
 #include "jsgcchunk.h"
 #include "jshashtable.h"
 #include "jsinterp.h"
 #include "jsobj.h"
--- a/js/src/jscompat.h
+++ b/js/src/jscompat.h
@@ -40,16 +40,15 @@
 #ifndef jscompat_h___
 #define jscompat_h___
 /*
  * Compatibility glue for various NSPR versions.  We must always define int8,
  * int16, jsword, and so on to minimize differences with js/ref, no matter what
  * the NSPR typedef names may be.
  */
 #include "jstypes.h"
-#include "jslong.h"
 
 typedef JSIntn intN;
 typedef JSUintn uintN;
 typedef JSUword jsuword;
 typedef JSWord jsword;
 typedef float float32;
 #endif /* jscompat_h___ */
deleted file mode 100644
--- a/js/src/jslong.h
+++ /dev/null
@@ -1,167 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 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
- * 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
- * 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 ***** */
-
-/*
-** File:                jslong.h
-** Description: Portable access to 64 bit numerics
-**
-** Long-long (64-bit signed integer type) support. Some C compilers
-** don't support 64 bit integers yet, so we use these macros to
-** support both machines that do and don't.
-**/
-#ifndef jslong_h___
-#define jslong_h___
-
-#include "jstypes.h"
-
-JS_BEGIN_EXTERN_C
-
-#define JSLL_INIT(hi, lo)  ((((JSInt64)(hi)) << 32) + (JSInt64)(lo))
-
-/***********************************************************************
-** MACROS:      JSLL_*
-** DESCRIPTION:
-**      The following macros define portable access to the 64 bit
-**      math facilities.
-**
-***********************************************************************/
-
-/***********************************************************************
-** MACROS:      JSLL_<relational operators>
-**
-**  JSLL_IS_ZERO        Test for zero
-**  JSLL_EQ             Test for equality
-**  JSLL_NE             Test for inequality
-**  JSLL_GE_ZERO        Test for zero or positive
-**  JSLL_CMP            Compare two values
-***********************************************************************/
-#define JSLL_IS_ZERO(a)       ((a) == 0)
-#define JSLL_EQ(a, b)         ((a) == (b))
-#define JSLL_NE(a, b)         ((a) != (b))
-#define JSLL_GE_ZERO(a)       ((a) >= 0)
-#define JSLL_CMP(a, op, b)    ((JSInt64)(a) op (JSInt64)(b))
-#define JSLL_UCMP(a, op, b)   ((JSUint64)(a) op (JSUint64)(b))
-
-/***********************************************************************
-** MACROS:      JSLL_<logical operators>
-**
-**  JSLL_AND            Logical and
-**  JSLL_OR             Logical or
-**  JSLL_XOR            Logical exclusion
-**  JSLL_OR2            A disgusting deviation
-**  JSLL_NOT            Negation (one's compliment)
-***********************************************************************/
-#define JSLL_AND(r, a, b)        ((r) = (a) & (b))
-#define JSLL_OR(r, a, b)        ((r) = (a) | (b))
-#define JSLL_XOR(r, a, b)        ((r) = (a) ^ (b))
-#define JSLL_OR2(r, a)        ((r) = (r) | (a))
-#define JSLL_NOT(r, a)        ((r) = ~(a))
-
-/***********************************************************************
-** MACROS:      JSLL_<mathematical operators>
-**
-**  JSLL_NEG            Negation (two's compliment)
-**  JSLL_ADD            Summation (two's compliment)
-**  JSLL_SUB            Difference (two's compliment)
-***********************************************************************/
-#define JSLL_NEG(r, a)        ((r) = -(a))
-#define JSLL_ADD(r, a, b)     ((r) = (a) + (b))
-#define JSLL_SUB(r, a, b)     ((r) = (a) - (b))
-
-/***********************************************************************
-** MACROS:      JSLL_<mathematical operators>
-**
-**  JSLL_MUL            Product (two's compliment)
-**  JSLL_DIV            Quotient (two's compliment)
-**  JSLL_MOD            Modulus (two's compliment)
-***********************************************************************/
-#define JSLL_MUL(r, a, b)        ((r) = (a) * (b))
-#define JSLL_DIV(r, a, b)        ((r) = (a) / (b))
-#define JSLL_MOD(r, a, b)        ((r) = (a) % (b))
-
-/***********************************************************************
-** MACROS:      JSLL_<shifting operators>
-**
-**  JSLL_SHL            Shift left [0..64] bits
-**  JSLL_SHR            Shift right [0..64] bits with sign extension
-**  JSLL_USHR           Unsigned shift right [0..64] bits
-**  JSLL_ISHL           Signed shift left [0..64] bits
-***********************************************************************/
-#define JSLL_SHL(r, a, b)     ((r) = (JSInt64)(a) << (b))
-#define JSLL_SHR(r, a, b)     ((r) = (JSInt64)(a) >> (b))
-#define JSLL_USHR(r, a, b)    ((r) = (JSUint64)(a) >> (b))
-#define JSLL_ISHL(r, a, b)    ((r) = (JSInt64)(a) << (b))
-
-/***********************************************************************
-** MACROS:      JSLL_<conversion operators>
-**
-**  JSLL_L2I            Convert to signed 32 bit
-**  JSLL_L2UI           Convert to unsigned 32 bit
-**  JSLL_L2F            Convert to floating point
-**  JSLL_L2D            Convert to floating point
-**  JSLL_I2L            Convert signed to 64 bit
-**  JSLL_UI2L           Convert unsigned to 64 bit
-**  JSLL_F2L            Convert float to 64 bit
-**  JSLL_D2L            Convert float to 64 bit
-***********************************************************************/
-#define JSLL_L2I(i, l)        ((i) = (JSInt32)(l))
-#define JSLL_L2UI(ui, l)        ((ui) = (JSUint32)(l))
-#define JSLL_L2F(f, l)        ((f) = (JSFloat64)(l))
-#define JSLL_L2D(d, l)        ((d) = (JSFloat64)(l))
-
-#define JSLL_I2L(l, i)        ((l) = (JSInt64)(i))
-#define JSLL_UI2L(l, ui)        ((l) = (JSInt64)(ui))
-#define JSLL_F2L(l, f)        ((l) = (JSInt64)(f))
-#define JSLL_D2L(l, d)        ((l) = (JSInt64)(d))
-
-/***********************************************************************
-** MACROS:      JSLL_UDIVMOD
-** DESCRIPTION:
-**  Produce both a quotient and a remainder given an unsigned
-** INPUTS:      JSUint64 a: The dividend of the operation
-**              JSUint64 b: The quotient of the operation
-** OUTPUTS:     JSUint64 *qp: pointer to quotient
-**              JSUint64 *rp: pointer to remainder
-***********************************************************************/
-#define JSLL_UDIVMOD(qp, rp, a, b) \
-    (*(qp) = ((JSUint64)(a) / (b)), \
-     *(rp) = ((JSUint64)(a) % (b)))
-
-JS_END_EXTERN_C
-
-#endif /* jslong_h___ */
--- a/js/src/jsmath.cpp
+++ b/js/src/jsmath.cpp
@@ -38,17 +38,16 @@
  * ***** END LICENSE BLOCK ***** */
 
 /*
  * JS math package.
  */
 #include <stdlib.h>
 #include "jstypes.h"
 #include "jsstdint.h"
-#include "jslong.h"
 #include "prmjtime.h"
 #include "jsapi.h"
 #include "jsatom.h"
 #include "jsbuiltins.h"
 #include "jscntxt.h"
 #include "jsversion.h"
 #include "jslock.h"
 #include "jsmath.h"
--- a/js/src/jsprf.cpp
+++ b/js/src/jsprf.cpp
@@ -42,17 +42,16 @@
 ** Author: Kipp E.B. Hickman
 */
 #include <stdarg.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include "jsprf.h"
 #include "jsstdint.h"
-#include "jslong.h"
 #include "jsutil.h"
 #include "jspubtd.h"
 #include "jsstr.h"
 
 using namespace js;
 
 /*
 ** Note: on some platforms va_list is defined as an array,
@@ -289,39 +288,34 @@ static int cvt_l(SprintfState *ss, long 
 }
 
 /*
 ** Convert a 64-bit integer into its printable form
 */
 static int cvt_ll(SprintfState *ss, JSInt64 num, int width, int prec, int radix,
                   int type, int flags, const char *hexp)
 {
-    char cvtbuf[100];
-    char *cvt;
-    int digits;
-    JSInt64 rad;
-
     /* according to the man page this needs to happen */
-    if ((prec == 0) && (JSLL_IS_ZERO(num))) {
+    if (prec == 0 && num == 0) {
         return 0;
     }
 
     /*
     ** Converting decimal is a little tricky. In the unsigned case we
     ** need to stop when we hit 10 digits. In the signed case, we can
     ** stop when the number is zero.
     */
-    JSLL_I2L(rad, radix);
-    cvt = cvtbuf + sizeof(cvtbuf);
-    digits = 0;
-    while (!JSLL_IS_ZERO(num)) {
-        JSInt32 digit;
-        JSInt64 quot, rem;
-        JSLL_UDIVMOD(&quot, &rem, num, rad);
-        JSLL_L2I(digit, rem);
+    JSInt64 rad = JSInt64(radix);
+    char cvtbuf[100];
+    char *cvt = cvtbuf + sizeof(cvtbuf);
+    int digits = 0;
+    while (num != 0) {
+        JSInt64 quot = JSUint64(num) / rad;
+        JSInt64 rem = JSUint64(num) % rad;
+        JSInt32 digit = JSInt32(rem);
         *--cvt = hexp[digit & 0xf];
         digits++;
         num = quot;
     }
     if (digits == 0) {
         *--cvt = '0';
         digits++;
     }
@@ -894,18 +888,18 @@ static int dosprintf(SprintfState *ss, c
                 rv = cvt_l(ss, u.l, width, prec, radix, type, flags, hexp);
                 if (rv < 0) {
                     return rv;
                 }
                 break;
 
               case TYPE_INT64:
                 u.ll = va_arg(ap, JSInt64);
-                if (!JSLL_GE_ZERO(u.ll)) {
-                    JSLL_NEG(u.ll, u.ll);
+                if (u.ll < 0) {
+                    u.ll = -u.ll;
                     flags |= FLAG_NEG;
                 }
                 goto do_longlong;
               case TYPE_UINT64:
                 u.ll = va_arg(ap, JSUint64);
               do_longlong:
                 rv = cvt_ll(ss, u.ll, width, prec, radix, type, flags, hexp);
                 if (rv < 0) {
--- a/js/src/prmjtime.cpp
+++ b/js/src/prmjtime.cpp
@@ -157,17 +157,17 @@ PRMJ_LocalGMTDifference()
 #define G1970GMTMICROHI        0x00dcdcad /* micro secs to 1970 hi */
 #define G1970GMTMICROLOW       0x8b3fa000 /* micro secs to 1970 low */
 
 #define G2037GMTMICROHI        0x00e45fab /* micro secs to 2037 high */
 #define G2037GMTMICROLOW       0x7a238000 /* micro secs to 2037 low */
 
 #ifdef HAVE_SYSTEMTIMETOFILETIME
 
-static const JSInt64 win2un = JSLL_INIT(0x19DB1DE, 0xD53E8000);
+static const JSInt64 win2un = 0x19DB1DED53E8000;
 
 #define FILETIME2INT64(ft) (((JSInt64)ft.dwHighDateTime) << 32LL | (JSInt64)ft.dwLowDateTime)
 
 #endif
 
 #if defined(HAVE_GETSYSTEMTIMEASFILETIME) || defined(HAVE_SYSTEMTIMETOFILETIME)
 
 #if defined(HAVE_GETSYSTEMTIMEASFILETIME)
@@ -295,43 +295,43 @@ static PRCallOnceType calibrationOnce = 
 #if defined(XP_OS2)
 JSInt64
 PRMJ_Now(void)
 {
     JSInt64 s, us, ms2us, s2us;
     struct timeb b;
 
     ftime(&b);
-    JSLL_UI2L(ms2us, PRMJ_USEC_PER_MSEC);
-    JSLL_UI2L(s2us, PRMJ_USEC_PER_SEC);
-    JSLL_UI2L(s, b.time);
-    JSLL_UI2L(us, b.millitm);
-    JSLL_MUL(us, us, ms2us);
-    JSLL_MUL(s, s, s2us);
-    JSLL_ADD(s, s, us);
+    ms2us = (JSInt64) PRMJ_USEC_PER_MSEC;
+    s2us = (JSInt64) PRMJ_USEC_PER_SEC;
+    s = (JSInt64) b.time;
+    us = (JSInt64) b.millitm;
+    us *= ms2us;
+    s *= s2us;
+    s += us;
     return s;
 }
 
 #elif defined(XP_UNIX)
 JSInt64
 PRMJ_Now(void)
 {
     struct timeval tv;
     JSInt64 s, us, s2us;
 
 #ifdef _SVID_GETTOD   /* Defined only on Solaris, see Solaris <sys/types.h> */
     gettimeofday(&tv);
 #else
     gettimeofday(&tv, 0);
 #endif /* _SVID_GETTOD */
-    JSLL_UI2L(s2us, PRMJ_USEC_PER_SEC);
-    JSLL_UI2L(s, tv.tv_sec);
-    JSLL_UI2L(us, tv.tv_usec);
-    JSLL_MUL(s, s, s2us);
-    JSLL_ADD(s, s, us);
+    s2us = (JSInt64) PRMJ_USEC_PER_SEC;
+    s = (JSInt64) tv.tv_sec;
+    us = (JSInt64) tv.tv_usec;
+    s *= s2us;
+    s += us;
     return s;
 }
 
 #else
 /*
 
 Win32 python-esque pseudo code
 Please see bug 363258 for why the win32 timing code is so complex.
--- a/js/src/prmjtime.h
+++ b/js/src/prmjtime.h
@@ -40,17 +40,16 @@
 #ifndef prmjtime_h___
 #define prmjtime_h___
 /*
  * PR date stuff for mocha and java. Placed here temporarily not to break
  * Navigator and localize changes to mocha.
  */
 #include <time.h>
 
-#include "jslong.h"
 #ifdef MOZILLA_CLIENT
 #include "jscompat.h"
 #endif
 
 struct JSContext;
 
 /*
  * Implements a small cache for daylight saving time offset computation.