lib/libtcc1.c

   1 /* TCC runtime library.
   2    Parts of this code are (c) 2002 Fabrice Bellard
   3
   4    Copyright (C) 1987, 1988, 1992, 1994, 1995 Free Software Foundation, Inc.
   5
   6 This file is free software; you can redistribute it and/or modify it
   7 under the terms of the GNU General Public License as published by the
   8 Free Software Foundation; either version 2, or (at your option) any
   9 later version.
  10
  11 In addition to the permissions in the GNU General Public License, the
  12 Free Software Foundation gives you unlimited permission to link the
  13 compiled version of this file into combinations with other programs,
  14 and to distribute those combinations without any restriction coming
  15 from the use of this file.  (The General Public License restrictions
  16 do apply in other respects; for example, they cover modification of
  17 the file, and distribution when not linked into a combine
  18 executable.)
  19
  20 This file is distributed in the hope that it will be useful, but
  21 WITHOUT ANY WARRANTY; without even the implied warranty of
  22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  23 General Public License for more details.
  24
  25 You should have received a copy of the GNU General Public License
  26 along with this program; see the file COPYING.  If not, write to
  27 the Free Software Foundation, 59 Temple Place - Suite 330,
  28 Boston, MA 02111-1307, USA.
  29 */
  30
  31 #define W_TYPE_SIZE   32
  32 #define BITS_PER_UNIT 8
  33
  34 typedef int Wtype;
  35 typedef unsigned int UWtype;
  36 typedef unsigned int USItype;
  37 typedef long long DWtype;
  38 typedef unsigned long long UDWtype;
  39
  40 struct DWstruct {
  41     Wtype low, high;
  42 };
  43
  44 typedef union
  45 {
  46   struct DWstruct s;
  47   DWtype ll;
  48 } DWunion;
  49
  50 typedef long double XFtype;
  51 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
  52 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
  53
  54 /* the following deal with IEEE single-precision numbers */
  55 #define EXCESS          126
  56 #define SIGNBIT         0x80000000
  57 #define HIDDEN          (1 << 23)
  58 #define SIGN(fp)        ((fp) & SIGNBIT)
  59 #define EXP(fp)         (((fp) >> 23) & 0xFF)
  60 #define MANT(fp)        (((fp) & 0x7FFFFF) | HIDDEN)
  61 #define PACK(s,e,m)     ((s) | ((e) << 23) | (m))
  62
  63 /* the following deal with IEEE double-precision numbers */
  64 #define EXCESSD         1022
  65 #define HIDDEND         (1 << 20)
  66 #define EXPD(fp)        (((fp.l.upper) >> 20) & 0x7FF)
  67 #define SIGND(fp)       ((fp.l.upper) & SIGNBIT)
  68 #define MANTD(fp)       (((((fp.l.upper) & 0xFFFFF) | HIDDEND) << 10) | \
  69                                 (fp.l.lower >> 22))
  70 #define HIDDEND_LL      ((long long)1 << 52)
  71 #define MANTD_LL(fp)    ((fp.ll & (HIDDEND_LL-1)) | HIDDEND_LL)
  72 #define PACKD_LL(s,e,m) (((long long)((s)+((e)<<20))<<32)|(m))
  73
  74 /* the following deal with x86 long double-precision numbers */
  75 #define EXCESSLD        16382
  76 #define EXPLD(fp)       (fp.l.upper & 0x7fff)
  77 #define SIGNLD(fp)      ((fp.l.upper) & 0x8000)
  78
  79 /* only for x86 */
  80 union ldouble_long {
  81     long double ld;
  82     struct {
  83         unsigned long long lower;
  84         unsigned short upper;
  85     } l;
  86 };
  87
  88 union double_long {
  89     double d;
  90 #if 1
  91     struct {
  92         unsigned int lower;
  93         int upper;
  94     } l;
  95 #else
  96     struct {
  97         int upper;
  98         unsigned int lower;
  99     } l;
 100 #endif
 101     long long ll;
 102 };
 103
 104 union float_long {
 105     float f;
 106     long l;
 107 };
 108
 109 /* XXX: we don't support several builtin supports for now */
 110 #if !defined(__x86_64__) && !defined(__arm__)
 111
 112 /* XXX: use gcc/tcc intrinsic ? */
 113 #if defined(__i386__)
 114 #define sub_ddmmss(sh, sl, ah, al, bh, bl) \
 115   __asm__ ("subl %5,%1\n\tsbbl %3,%0"                                   \
 116            : "=r" ((USItype) (sh)),                                     \
 117              "=&r" ((USItype) (sl))                                     \
 118            : "0" ((USItype) (ah)),                                      \
 119              "g" ((USItype) (bh)),                                      \
 120              "1" ((USItype) (al)),                                      \
 121              "g" ((USItype) (bl)))
 122 #define umul_ppmm(w1, w0, u, v) \
 123   __asm__ ("mull %3"                                                    \
 124            : "=a" ((USItype) (w0)),                                     \
 125              "=d" ((USItype) (w1))                                      \
 126            : "%0" ((USItype) (u)),                                      \
 127              "rm" ((USItype) (v)))
 128 #define udiv_qrnnd(q, r, n1, n0, dv) \
 129   __asm__ ("divl %4"                                                    \
 130            : "=a" ((USItype) (q)),                                      \
 131              "=d" ((USItype) (r))                                       \
 132            : "0" ((USItype) (n0)),                                      \
 133              "1" ((USItype) (n1)),                                      \
 134              "rm" ((USItype) (dv)))
 135 #define count_leading_zeros(count, x) \
 136   do {                                                                  \
 137     USItype __cbtmp;                                                    \
 138     __asm__ ("bsrl %1,%0"                                               \
 139              : "=r" (__cbtmp) : "rm" ((USItype) (x)));                  \
 140     (count) = __cbtmp ^ 31;                                             \
 141   } while (0)
 142 #else
 143 #error unsupported CPU type
 144 #endif
 145
 146 /* most of this code is taken from libgcc2.c from gcc */
 147
 148 static UDWtype __udivmoddi4 (UDWtype n, UDWtype d, UDWtype *rp)
 149 {
 150   DWunion ww;
 151   DWunion nn, dd;
 152   DWunion rr;
 153   UWtype d0, d1, n0, n1, n2;
 154   UWtype q0, q1;
 155   UWtype b, bm;
 156
 157   nn.ll = n;
 158   dd.ll = d;
 159
 160   d0 = dd.s.low;
 161   d1 = dd.s.high;
 162   n0 = nn.s.low;
 163   n1 = nn.s.high;
 164
 165 #if !defined(UDIV_NEEDS_NORMALIZATION)
 166   if (d1 == 0)
 167     {
 168       if (d0 > n1)
 169         {
 170           /* 0q = nn / 0D */
 171
 172           udiv_qrnnd (q0, n0, n1, n0, d0);
 173           q1 = 0;
 174
 175           /* Remainder in n0.  */
 176         }
 177       else
 178         {
 179           /* qq = NN / 0d */
 180
 181           if (d0 == 0)
 182             d0 = 1 / d0;        /* Divide intentionally by zero.  */
 183
 184           udiv_qrnnd (q1, n1, 0, n1, d0);
 185           udiv_qrnnd (q0, n0, n1, n0, d0);
 186
 187           /* Remainder in n0.  */
 188         }
 189
 190       if (rp != 0)
 191         {
 192           rr.s.low = n0;
 193           rr.s.high = 0;
 194           *rp = rr.ll;
 195         }
 196     }
 197
 198 #else /* UDIV_NEEDS_NORMALIZATION */
 199
 200   if (d1 == 0)
 201     {
 202       if (d0 > n1)
 203         {
 204           /* 0q = nn / 0D */
 205
 206           count_leading_zeros (bm, d0);
 207
 208           if (bm != 0)
 209             {
 210               /* Normalize, i.e. make the most significant bit of the
 211                  denominator set.  */
 212
 213               d0 = d0 << bm;
 214               n1 = (n1 << bm) | (n0 >> (W_TYPE_SIZE - bm));
 215               n0 = n0 << bm;
 216             }
 217
 218           udiv_qrnnd (q0, n0, n1, n0, d0);
 219           q1 = 0;
 220
 221           /* Remainder in n0 >> bm.  */
 222         }
 223       else
 224         {
 225           /* qq = NN / 0d */
 226
 227           if (d0 == 0)
 228             d0 = 1 / d0;        /* Divide intentionally by zero.  */
 229
 230           count_leading_zeros (bm, d0);
 231
 232           if (bm == 0)
 233             {
 234               /* From (n1 >= d0) /\ (the most significant bit of d0 is set),
 235                  conclude (the most significant bit of n1 is set) /\ (the
 236                  leading quotient digit q1 = 1).
 237
 238                  This special case is necessary, not an optimization.
 239                  (Shifts counts of W_TYPE_SIZE are undefined.)  */
 240
 241               n1 -= d0;
 242               q1 = 1;
 243             }
 244           else
 245             {
 246               /* Normalize.  */
 247
 248               b = W_TYPE_SIZE - bm;
 249
 250               d0 = d0 << bm;
 251               n2 = n1 >> b;
 252               n1 = (n1 << bm) | (n0 >> b);
 253               n0 = n0 << bm;
 254
 255               udiv_qrnnd (q1, n1, n2, n1, d0);
 256             }
 257
 258           /* n1 != d0...  */
 259
 260           udiv_qrnnd (q0, n0, n1, n0, d0);
 261
 262           /* Remainder in n0 >> bm.  */
 263         }
 264
 265       if (rp != 0)
 266         {
 267           rr.s.low = n0 >> bm;
 268           rr.s.high = 0;
 269           *rp = rr.ll;
 270         }
 271     }
 272 #endif /* UDIV_NEEDS_NORMALIZATION */
 273
 274   else
 275     {
 276       if (d1 > n1)
 277         {
 278           /* 00 = nn / DD */
 279
 280           q0 = 0;
 281           q1 = 0;
 282
 283           /* Remainder in n1n0.  */
 284           if (rp != 0)
 285             {
 286               rr.s.low = n0;
 287               rr.s.high = n1;
 288               *rp = rr.ll;
 289             }
 290         }
 291       else
 292         {
 293           /* 0q = NN / dd */
 294
 295           count_leading_zeros (bm, d1);
 296           if (bm == 0)
 297             {
 298               /* From (n1 >= d1) /\ (the most significant bit of d1 is set),
 299                  conclude (the most significant bit of n1 is set) /\ (the
 300                  quotient digit q0 = 0 or 1).
 301
 302                  This special case is necessary, not an optimization.  */
 303
 304               /* The condition on the next line takes advantage of that
 305                  n1 >= d1 (true due to program flow).  */
 306               if (n1 > d1 || n0 >= d0)
 307                 {
 308                   q0 = 1;
 309                   sub_ddmmss (n1, n0, n1, n0, d1, d0);
 310                 }
 311               else
 312                 q0 = 0;
 313
 314               q1 = 0;
 315
 316               if (rp != 0)
 317                 {
 318                   rr.s.low = n0;
 319                   rr.s.high = n1;
 320                   *rp = rr.ll;
 321                 }
 322             }
 323           else
 324             {
 325               UWtype m1, m0;
 326               /* Normalize.  */
 327
 328               b = W_TYPE_SIZE - bm;
 329
 330               d1 = (d1 << bm) | (d0 >> b);
 331               d0 = d0 << bm;
 332               n2 = n1 >> b;
 333               n1 = (n1 << bm) | (n0 >> b);
 334               n0 = n0 << bm;
 335
 336               udiv_qrnnd (q0, n1, n2, n1, d1);
 337               umul_ppmm (m1, m0, q0, d0);
 338
 339               if (m1 > n1 || (m1 == n1 && m0 > n0))
 340                 {
 341                   q0--;
 342                   sub_ddmmss (m1, m0, m1, m0, d1, d0);
 343                 }
 344
 345               q1 = 0;
 346
 347               /* Remainder in (n1n0 - m1m0) >> bm.  */
 348               if (rp != 0)
 349                 {
 350                   sub_ddmmss (n1, n0, n1, n0, m1, m0);
 351                   rr.s.low = (n1 << b) | (n0 >> bm);
 352                   rr.s.high = n1 >> bm;
 353                   *rp = rr.ll;
 354                 }
 355             }
 356         }
 357     }
 358
 359   ww.s.low = q0;
 360   ww.s.high = q1;
 361   return ww.ll;
 362 }
 363
 364 #define __negdi2(a) (-(a))
 365
 366 long long __divdi3(long long u, long long v)
 367 {
 368     int c = 0;
 369     DWunion uu, vv;
 370     DWtype w;
 371
 372     uu.ll = u;
 373     vv.ll = v;
 374
 375     if (uu.s.high < 0) {
 376         c = ~c;
 377         uu.ll = __negdi2 (uu.ll);
 378     }
 379     if (vv.s.high < 0) {
 380         c = ~c;
 381         vv.ll = __negdi2 (vv.ll);
 382     }
 383     w = __udivmoddi4 (uu.ll, vv.ll, (UDWtype *) 0);
 384     if (c)
 385         w = __negdi2 (w);
 386     return w;
 387 }
 388
 389 long long __moddi3(long long u, long long v)
 390 {
 391     int c = 0;
 392     DWunion uu, vv;
 393     DWtype w;
 394
 395     uu.ll = u;
 396     vv.ll = v;
 397
 398     if (uu.s.high < 0) {
 399         c = ~c;
 400         uu.ll = __negdi2 (uu.ll);
 401     }
 402     if (vv.s.high < 0)
 403         vv.ll = __negdi2 (vv.ll);
 404
 405     __udivmoddi4 (uu.ll, vv.ll, (UDWtype *) &w);
 406     if (c)
 407         w = __negdi2 (w);
 408     return w;
 409 }
 410
 411 unsigned long long __udivdi3(unsigned long long u, unsigned long long v)
 412 {
 413     return __udivmoddi4 (u, v, (UDWtype *) 0);
 414 }
 415
 416 unsigned long long __umoddi3(unsigned long long u, unsigned long long v)
 417 {
 418     UDWtype w;
 419
 420     __udivmoddi4 (u, v, &w);
 421     return w;
 422 }
 423
 424 /* XXX: fix tcc's code generator to do this instead */
 425 long long __ashrdi3(long long a, int b)
 426 {
 427 #ifdef __TINYC__
 428     DWunion u;
 429     u.ll = a;
 430     if (b >= 32) {
 431         u.s.low = u.s.high >> (b - 32);
 432         u.s.high = u.s.high >> 31;
 433     } else if (b != 0) {
 434         u.s.low = ((unsigned)u.s.low >> b) | (u.s.high << (32 - b));
 435         u.s.high = u.s.high >> b;
 436     }
 437     return u.ll;
 438 #else
 439     return a >> b;
 440 #endif
 441 }
 442
 443 /* XXX: fix tcc's code generator to do this instead */
 444 unsigned long long __lshrdi3(unsigned long long a, int b)
 445 {
 446 #ifdef __TINYC__
 447     DWunion u;
 448     u.ll = a;
 449     if (b >= 32) {
 450         u.s.low = (unsigned)u.s.high >> (b - 32);
 451         u.s.high = 0;
 452     } else if (b != 0) {
 453         u.s.low = ((unsigned)u.s.low >> b) | (u.s.high << (32 - b));
 454         u.s.high = (unsigned)u.s.high >> b;
 455     }
 456     return u.ll;
 457 #else
 458     return a >> b;
 459 #endif
 460 }
 461
 462 /* XXX: fix tcc's code generator to do this instead */
 463 long long __ashldi3(long long a, int b)
 464 {
 465 #ifdef __TINYC__
 466     DWunion u;
 467     u.ll = a;
 468     if (b >= 32) {
 469         u.s.high = (unsigned)u.s.low << (b - 32);
 470         u.s.low = 0;
 471     } else if (b != 0) {
 472         u.s.high = ((unsigned)u.s.high << b) | ((unsigned)u.s.low >> (32 - b));
 473         u.s.low = (unsigned)u.s.low << b;
 474     }
 475     return u.ll;
 476 #else
 477     return a << b;
 478 #endif
 479 }
 480
 481 #endif /* !__x86_64__ */
 482
 483 /* XXX: fix tcc's code generator to do this instead */
 484 float __floatundisf(unsigned long long a)
 485 {
 486     DWunion uu;
 487     XFtype r;
 488
 489     uu.ll = a;
 490     if (uu.s.high >= 0) {
 491         return (float)uu.ll;
 492     } else {
 493         r = (XFtype)uu.ll;
 494         r += 18446744073709551616.0;
 495         return (float)r;
 496     }
 497 }
 498
 499 double __floatundidf(unsigned long long a)
 500 {
 501     DWunion uu;
 502     XFtype r;
 503
 504     uu.ll = a;
 505     if (uu.s.high >= 0) {
 506         return (double)uu.ll;
 507     } else {
 508         r = (XFtype)uu.ll;
 509         r += 18446744073709551616.0;
 510         return (double)r;
 511     }
 512 }
 513
 514 long double __floatundixf(unsigned long long a)
 515 {
 516     DWunion uu;
 517     XFtype r;
 518
 519     uu.ll = a;
 520     if (uu.s.high >= 0) {
 521         return (long double)uu.ll;
 522     } else {
 523         r = (XFtype)uu.ll;
 524         r += 18446744073709551616.0;
 525         return (long double)r;
 526     }
 527 }
 528
 529 unsigned long long __fixunssfdi (float a1)
 530 {
 531     register union float_long fl1;
 532     register int exp;
 533     register unsigned long l;
 534
 535     fl1.f = a1;
 536
 537     if (fl1.l == 0)
 538         return (0);
 539
 540     exp = EXP (fl1.l) - EXCESS - 24;
 541
 542     l = MANT(fl1.l);
 543     if (exp >= 41)
 544         return (unsigned long long)-1;
 545     else if (exp >= 0)
 546         return (unsigned long long)l << exp;
 547     else if (exp >= -23)
 548         return l >> -exp;
 549     else
 550         return 0;
 551 }
 552
 553 unsigned long long __fixunsdfdi (double a1)
 554 {
 555     register union double_long dl1;
 556     register int exp;
 557     register unsigned long long l;
 558
 559     dl1.d = a1;
 560
 561     if (dl1.ll == 0)
 562         return (0);
 563
 564     exp = EXPD (dl1) - EXCESSD - 53;
 565
 566     l = MANTD_LL(dl1);
 567
 568     if (exp >= 12)
 569         return (unsigned long long)-1;
 570     else if (exp >= 0)
 571         return l << exp;
 572     else if (exp >= -52)
 573         return l >> -exp;
 574     else
 575         return 0;
 576 }
 577
 578 unsigned long long __fixunsxfdi (long double a1)
 579 {
 580     register union ldouble_long dl1;
 581     register int exp;
 582     register unsigned long long l;
 583
 584     dl1.ld = a1;
 585
 586     if (dl1.l.lower == 0 && dl1.l.upper == 0)
 587         return (0);
 588
 589     exp = EXPLD (dl1) - EXCESSLD - 64;
 590
 591     l = dl1.l.lower;
 592
 593     if (exp > 0)
 594         return (unsigned long long)-1;
 595     else if (exp >= -63)
 596         return l >> -exp;
 597     else
 598         return 0;
 599 }
 600
 601 long long __fixsfdi (float a1)
 602 {
 603     long long ret; int s;
 604     ret = __fixunssfdi((s = a1 >= 0) ? a1 : -a1);
 605     return s ? ret : -ret;
 606 }
 607
 608 long long __fixdfdi (double a1)
 609 {
 610     long long ret; int s;
 611     ret = __fixunsdfdi((s = a1 >= 0) ? a1 : -a1);
 612     return s ? ret : -ret;
 613 }
 614
 615 long long __fixxfdi (long double a1)
 616 {
 617     long long ret; int s;
 618     ret = __fixunsxfdi((s = a1 >= 0) ? a1 : -a1);
 619     return s ? ret : -ret;
 620 }
 621
 622 #if defined(__x86_64__) && !defined(_WIN64)
 623
 624 #ifndef __TINYC__
 625 #include <stdlib.h>
 626 #include <stdio.h>
 627 #else
 628 /* Avoid including stdlib.h because it is not easily available when
 629    cross compiling */
 630 extern void *malloc(unsigned long long);
 631 extern void free(void*);
 632 extern void abort(void);
 633 #endif
 634
 635 enum __va_arg_type {
 636     __va_gen_reg, __va_float_reg, __va_stack
 637 };
 638
 639 /* GCC compatible definition of va_list. */
 640 struct __va_list_struct {
 641     unsigned int gp_offset;
 642     unsigned int fp_offset;
 643     union {
 644         unsigned int overflow_offset;
 645         char *overflow_arg_area;
 646     };
 647     char *reg_save_area;
 648 };
 649
 650 void *__va_start(void *fp)
 651 {
 652     struct __va_list_struct *ap =
 653         (struct __va_list_struct *)malloc(sizeof(struct __va_list_struct));
 654     *ap = *(struct __va_list_struct *)((char *)fp - 16);
 655     ap->overflow_arg_area = (char *)fp + ap->overflow_offset;
 656     ap->reg_save_area = (char *)fp - 176 - 16;
 657     return ap;
 658 }
 659
 660 void *__va_arg(struct __va_list_struct *ap,
 661                enum __va_arg_type arg_type,
 662                int size, int align)
 663 {
 664     size = (size + 7) & ~7;
 665     align = (align + 7) & ~7;
 666     switch (arg_type) {
 667     case __va_gen_reg:
 668         if (ap->gp_offset < 48) {
 669             ap->gp_offset += 8;
 670             return ap->reg_save_area + ap->gp_offset - 8;
 671         }
 672         size = 8;
 673         goto use_overflow_area;
 674
 675     case __va_float_reg:
 676         if (ap->fp_offset < 128 + 48) {
 677             ap->fp_offset += 16;
 678             return ap->reg_save_area + ap->fp_offset - 16;
 679         }
 680         size = 8;
 681         goto use_overflow_area;
 682
 683     case __va_stack:
 684     use_overflow_area:
 685         ap->overflow_arg_area += size;
 686         ap->overflow_arg_area = (char*)((long long)(ap->overflow_arg_area + align - 1) & -(long long)align);
 687         return ap->overflow_arg_area - size;
 688
 689     default:
 690 #ifndef __TINYC__
 691         fprintf(stderr, "unknown ABI type for __va_arg\n");
 692 #endif
 693         abort();
 694     }
 695 }
 696
 697 void *__va_copy(struct __va_list_struct *src)
 698 {
 699     struct __va_list_struct *dest =
 700         (struct __va_list_struct *)malloc(sizeof(struct __va_list_struct));
 701     *dest = *src;
 702     return dest;
 703 }
 704
 705 void __va_end(struct __va_list_struct *ap)
 706 {
 707     free(ap);
 708 }
 709
 710 #endif /* __x86_64__ */
 711
 712 /* Flushing for tccrun */
 713 #if defined(__x86_64__) || defined(__i386__)
 714
 715 void __clear_cache(char *beginning, char *end)
 716 {
 717 }
 718
 719 #elif defined(__arm__)
 720
 721 #define _GNU_SOURCE
 722 #include <unistd.h>
 723 #include <sys/syscall.h>
 724
 725 void __clear_cache(char *beginning, char *end)
 726 {
 727 /* __ARM_NR_cacheflush is kernel private and should not be used in user space.
 728  * However, there is no ARM asm parser in tcc so we use it for now */
 729 #if 1
 730     syscall(__ARM_NR_cacheflush);
 731 #else
 732     __asm__ ("push {r7}\n\t"
 733              "mov r7, #0xf0002\n\t"
 734              "mov r2, #0\n\t"
 735              "swi 0\n\t"
 736              "pop {r7}\n\t"
 737              "ret");
 738 #endif
 739 }
 740
 741 #else
 742 #warning __clear_cache not defined for this architecture, avoid using tcc -run
 743 #endif