1 /*

     2  * Utility compute operations used by translated code.

     3  *

     4  * Copyright (c) 2003 Fabrice Bellard

     5  * Copyright (c) 2007 Aurelien Jarno

     6  *

     7  * Permission is hereby granted, free of charge, to any person obtaining a copy

     8  * of this software and associated documentation files (the "Software"), to deal

     9  * in the Software without restriction, including without limitation the rights

    10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

    11  * copies of the Software, and to permit persons to whom the Software is

    12  * furnished to do so, subject to the following conditions:

    13  *

    14  * The above copyright notice and this permission notice shall be included in

    15  * all copies or substantial portions of the Software.

    16  *

    17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

    18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

    19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

    20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

    21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

    22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

    23  * THE SOFTWARE.

    24  */

    25 

    26 #include "exec.h"

    27 #include "host-utils.h"

    28 

    29 //#define DEBUG_MULDIV

    30 

    31 /* Long integer helpers */

    32 #if !defined(__x86_64__)

    33 static void add128 (uint64_t *plow, uint64_t *phigh, uint64_t a, uint64_t b)

    34 {

    35     *plow += a;

    36     /* carry test */

    37     if (*plow < a)

    38         (*phigh)++;

    39     *phigh += b;

    40 }

    41 

    42 static void neg128 (uint64_t *plow, uint64_t *phigh)

    43 {

    44     *plow = ~*plow;

    45     *phigh = ~*phigh;

    46     add128(plow, phigh, 1, 0);

    47 }

    48 

    49 static void mul64 (uint64_t *plow, uint64_t *phigh, uint64_t a, uint64_t b)

    50 {

    51     uint32_t a0, a1, b0, b1;

    52     uint64_t v;

    53 

    54     a0 = a;

    55     a1 = a >> 32;

    56 

    57     b0 = b;

    58     b1 = b >> 32;

    59 

    60     v = (uint64_t)a0 * (uint64_t)b0;

    61     *plow = v;

    62     *phigh = 0;

    63 

    64     v = (uint64_t)a0 * (uint64_t)b1;

    65     add128(plow, phigh, v << 32, v >> 32);

    66 

    67     v = (uint64_t)a1 * (uint64_t)b0;

    68     add128(plow, phigh, v << 32, v >> 32);

    69 

    70     v = (uint64_t)a1 * (uint64_t)b1;

    71     *phigh += v;

    72 }

    73 

    74 /* Unsigned 64x64 -> 128 multiplication */

    75 void mulu64 (uint64_t *plow, uint64_t *phigh, uint64_t a, uint64_t b)

    76 {

    77     mul64(plow, phigh, a, b);

    78 #if defined(DEBUG_MULDIV)

    79     printf("mulu64: 0x%016llx * 0x%016llx = 0x%016llx%016llx\n",

    80            a, b, *phigh, *plow);

    81 #endif

    82 }

    83 

    84 /* Signed 64x64 -> 128 multiplication */

    85 void muls64 (uint64_t *plow, uint64_t *phigh, int64_t a, int64_t b)

    86 {

    87     int sa, sb;

    88 

    89     sa = (a < 0);

    90     if (sa)

    91         a = -a;

    92     sb = (b < 0);

    93     if (sb)

    94         b = -b;

    95     mul64(plow, phigh, a, b);

    96     if (sa ^ sb) {

    97         neg128(plow, phigh);

    98     }

    99 #if defined(DEBUG_MULDIV)

   100     printf("muls64: 0x%016llx * 0x%016llx = 0x%016llx%016llx\n",

   101            a, b, *phigh, *plow);

   102 #endif

   103 }

   104 #endif /* !defined(__x86_64__) */