src/dom/js/jscpucfg.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
   2  *
   3  * ***** BEGIN LICENSE BLOCK *****
   4  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version
   7  * 1.1 (the "License"); you may not use this file except in compliance with
   8  * the License. You may obtain a copy of the License at
   9  * http://www.mozilla.org/MPL/
  10  *
  11  * Software distributed under the License is distributed on an "AS IS" basis,
  12  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13  * for the specific language governing rights and limitations under the
  14  * License.
  15  *
  16  * The Original Code is Mozilla Communicator client code, released
  17  * March 31, 1998.
  18  *
  19  * The Initial Developer of the Original Code is
  20  * Netscape Communications Corporation.
  21  * Portions created by the Initial Developer are Copyright (C) 1998
  22  * the Initial Developer. All Rights Reserved.
  23  *
  24  * Contributor(s):
  25  *   Roland Mainz <roland.mainz@informatik.med.uni-giessen.de>
  26  *
  27  * Alternatively, the contents of this file may be used under the terms of
  28  * either of the GNU General Public License Version 2 or later (the "GPL"),
  29  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  30  * in which case the provisions of the GPL or the LGPL are applicable instead
  31  * of those above. If you wish to allow use of your version of this file only
  32  * under the terms of either the GPL or the LGPL, and not to allow others to
  33  * use your version of this file under the terms of the MPL, indicate your
  34  * decision by deleting the provisions above and replace them with the notice
  35  * and other provisions required by the GPL or the LGPL. If you do not delete
  36  * the provisions above, a recipient may use your version of this file under
  37  * the terms of any one of the MPL, the GPL or the LGPL.
  38  *
  39  * ***** END LICENSE BLOCK ***** */
  40
  41 /*
  42  * Generate CPU-specific bit-size and similar #defines.
  43  */
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46
  47 #ifdef CROSS_COMPILE
  48 #include <prtypes.h>
  49 #define INT64 PRInt64
  50 #else
  51
  52 #ifdef __MWERKS__
  53 #define XP_MAC 1
  54 #endif
  55
  56 /************************************************************************/
  57
  58 /* Generate cpucfg.h */
  59 #ifdef XP_MAC
  60 #include <Types.h>
  61 #define INT64   UnsignedWide
  62 #else
  63 #if defined(XP_WIN) || defined(XP_OS2)
  64 #ifdef WIN32
  65 #if defined(__GNUC__)
  66 #define INT64   long long
  67 #else
  68 #define INT64   _int64
  69 #endif /* __GNUC__ */
  70 #else
  71 #define INT64   long
  72 #endif
  73 #else
  74 #if defined(HPUX) || defined(__QNX__) || defined(_SCO_DS) || defined(UNIXWARE)
  75 #define INT64   long
  76 #else
  77 #define INT64   long long
  78 #endif
  79 #endif
  80 #endif
  81
  82 #endif /* CROSS_COMPILE */
  83
  84 typedef void *prword;
  85
  86 struct align_short {
  87     char c;
  88     short a;
  89 };
  90 struct align_int {
  91     char c;
  92     int a;
  93 };
  94 struct align_long {
  95     char c;
  96     long a;
  97 };
  98 struct align_int64 {
  99     char c;
 100     INT64 a;
 101 };
 102 struct align_fakelonglong {
 103     char c;
 104     struct {
 105         long hi, lo;
 106     } a;
 107 };
 108 struct align_float {
 109     char c;
 110     float a;
 111 };
 112 struct align_double {
 113     char c;
 114     double a;
 115 };
 116 struct align_pointer {
 117     char c;
 118     void *a;
 119 };
 120 struct align_prword {
 121     char c;
 122     prword a;
 123 };
 124
 125 #define ALIGN_OF(type) \
 126     (((char*)&(((struct align_##type *)0)->a)) - ((char*)0))
 127
 128 unsigned int bpb;
 129
 130 static int Log2(unsigned int n)
 131 {
 132     int log2 = 0;
 133
 134     if (n & (n-1))
 135         log2++;
 136     if (n >> 16)
 137         log2 += 16, n >>= 16;
 138     if (n >> 8)
 139         log2 += 8, n >>= 8;
 140     if (n >> 4)
 141         log2 += 4, n >>= 4;
 142     if (n >> 2)
 143         log2 += 2, n >>= 2;
 144     if (n >> 1)
 145         log2++;
 146     return log2;
 147 }
 148
 149 /*
 150  * Conceivably this could actually be used, but there is lots of code out
 151  * there with ands and shifts in it that assumes a byte is exactly 8 bits,
 152  * so forget about porting THIS code to all those non 8 bit byte machines.
 153  */
 154 static void BitsPerByte(void)
 155 {
 156     bpb = 8;
 157 }
 158
 159 static int StackGrowthDirection(int *dummy1addr)
 160 {
 161     int dummy2;
 162
 163     return (&dummy2 < dummy1addr) ? -1 : 1;
 164 }
 165
 166 int main(int argc, char **argv)
 167 {
 168     int sizeof_char, sizeof_short, sizeof_int, sizeof_int64, sizeof_long,
 169         sizeof_float, sizeof_double, sizeof_word, sizeof_dword;
 170     int bits_per_int64_log2, align_of_short, align_of_int, align_of_long,
 171         align_of_int64, align_of_float, align_of_double, align_of_pointer,
 172         align_of_word;
 173     int dummy1;
 174
 175     BitsPerByte();
 176
 177     printf("#ifndef js_cpucfg___\n");
 178     printf("#define js_cpucfg___\n\n");
 179
 180     printf("/* AUTOMATICALLY GENERATED - DO NOT EDIT */\n\n");
 181
 182 #ifdef CROSS_COMPILE
 183 #if defined(IS_LITTLE_ENDIAN)
 184     printf("#define IS_LITTLE_ENDIAN 1\n");
 185     printf("#undef  IS_BIG_ENDIAN\n\n");
 186 #elif defined(IS_BIG_ENDIAN)
 187     printf("#undef  IS_LITTLE_ENDIAN\n");
 188     printf("#define IS_BIG_ENDIAN 1\n\n");
 189 #else
 190 #error "Endianess not defined."
 191 #endif
 192
 193     sizeof_char         = PR_BYTES_PER_BYTE;
 194     sizeof_short        = PR_BYTES_PER_SHORT;
 195     sizeof_int          = PR_BYTES_PER_INT;
 196     sizeof_int64        = PR_BYTES_PER_INT64;
 197     sizeof_long         = PR_BYTES_PER_LONG;
 198     sizeof_float        = PR_BYTES_PER_FLOAT;
 199     sizeof_double       = PR_BYTES_PER_DOUBLE;
 200     sizeof_word         = PR_BYTES_PER_WORD;
 201     sizeof_dword        = PR_BYTES_PER_DWORD;
 202
 203     bits_per_int64_log2 = PR_BITS_PER_INT64_LOG2;
 204
 205     align_of_short      = PR_ALIGN_OF_SHORT;
 206     align_of_int        = PR_ALIGN_OF_INT;
 207     align_of_long       = PR_ALIGN_OF_LONG;
 208     align_of_int64      = PR_ALIGN_OF_INT64;
 209     align_of_float      = PR_ALIGN_OF_FLOAT;
 210     align_of_double     = PR_ALIGN_OF_DOUBLE;
 211     align_of_pointer    = PR_ALIGN_OF_POINTER;
 212     align_of_word       = PR_ALIGN_OF_WORD;
 213
 214 #else /* !CROSS_COMPILE */
 215
 216     /*
 217      * We don't handle PDP-endian or similar orders: if a short is big-endian,
 218      * so must int and long be big-endian for us to generate the IS_BIG_ENDIAN
 219      * #define and the IS_LITTLE_ENDIAN #undef.
 220      */
 221     {
 222         int big_endian = 0, little_endian = 0, ntests = 0;
 223
 224         if (sizeof(short) == 2) {
 225             /* force |volatile| here to get rid of any compiler optimisations
 226              * (var in register etc.) which may be appiled to |auto| vars -
 227              * even those in |union|s...
 228              * (|static| is used to get the same functionality for compilers
 229              * which do not honor |volatile|...).
 230              */
 231             volatile static union {
 232                 short i;
 233                 char c[2];
 234             } u;
 235
 236             u.i = 0x0102;
 237             big_endian += (u.c[0] == 0x01 && u.c[1] == 0x02);
 238             little_endian += (u.c[0] == 0x02 && u.c[1] == 0x01);
 239             ntests++;
 240         }
 241
 242         if (sizeof(int) == 4) {
 243             /* force |volatile| here ... */
 244             volatile static union {
 245                 int i;
 246                 char c[4];
 247             } u;
 248
 249             u.i = 0x01020304;
 250             big_endian += (u.c[0] == 0x01 && u.c[1] == 0x02 &&
 251                            u.c[2] == 0x03 && u.c[3] == 0x04);
 252             little_endian += (u.c[0] == 0x04 && u.c[1] == 0x03 &&
 253                               u.c[2] == 0x02 && u.c[3] == 0x01);
 254             ntests++;
 255         }
 256
 257         if (sizeof(long) == 8) {
 258             /* force |volatile| here ... */
 259             volatile static union {
 260                 long i;
 261                 char c[8];
 262             } u;
 263
 264             /*
 265              * Write this as portably as possible: avoid 0x0102030405060708L
 266              * and <<= 32.
 267              */
 268             u.i = 0x01020304;
 269             u.i <<= 16, u.i <<= 16;
 270             u.i |= 0x05060708;
 271             big_endian += (u.c[0] == 0x01 && u.c[1] == 0x02 &&
 272                            u.c[2] == 0x03 && u.c[3] == 0x04 &&
 273                            u.c[4] == 0x05 && u.c[5] == 0x06 &&
 274                            u.c[6] == 0x07 && u.c[7] == 0x08);
 275             little_endian += (u.c[0] == 0x08 && u.c[1] == 0x07 &&
 276                               u.c[2] == 0x06 && u.c[3] == 0x05 &&
 277                               u.c[4] == 0x04 && u.c[5] == 0x03 &&
 278                               u.c[6] == 0x02 && u.c[7] == 0x01);
 279             ntests++;
 280         }
 281
 282         if (big_endian && big_endian == ntests) {
 283             printf("#undef  IS_LITTLE_ENDIAN\n");
 284             printf("#define IS_BIG_ENDIAN 1\n\n");
 285         } else if (little_endian && little_endian == ntests) {
 286             printf("#define IS_LITTLE_ENDIAN 1\n");
 287             printf("#undef  IS_BIG_ENDIAN\n\n");
 288         } else {
 289             fprintf(stderr, "%s: unknown byte order"
 290                     "(big_endian=%d, little_endian=%d, ntests=%d)!\n",
 291                     argv[0], big_endian, little_endian, ntests);
 292             return EXIT_FAILURE;
 293         }
 294     }
 295
 296     sizeof_char         = sizeof(char);
 297     sizeof_short        = sizeof(short);
 298     sizeof_int          = sizeof(int);
 299     sizeof_int64        = 8;
 300     sizeof_long         = sizeof(long);
 301     sizeof_float        = sizeof(float);
 302     sizeof_double       = sizeof(double);
 303     sizeof_word         = sizeof(prword);
 304     sizeof_dword        = 8;
 305
 306     bits_per_int64_log2 = 6;
 307
 308     align_of_short      = ALIGN_OF(short);
 309     align_of_int        = ALIGN_OF(int);
 310     align_of_long       = ALIGN_OF(long);
 311     if (sizeof(INT64) < 8) {
 312         /* this machine doesn't actually support int64's */
 313         align_of_int64  = ALIGN_OF(fakelonglong);
 314     } else {
 315         align_of_int64  = ALIGN_OF(int64);
 316     }
 317     align_of_float      = ALIGN_OF(float);
 318     align_of_double     = ALIGN_OF(double);
 319     align_of_pointer    = ALIGN_OF(pointer);
 320     align_of_word       = ALIGN_OF(prword);
 321
 322 #endif /* CROSS_COMPILE */
 323
 324     printf("#define JS_BYTES_PER_BYTE   %dL\n", sizeof_char);
 325     printf("#define JS_BYTES_PER_SHORT  %dL\n", sizeof_short);
 326     printf("#define JS_BYTES_PER_INT    %dL\n", sizeof_int);
 327     printf("#define JS_BYTES_PER_INT64  %dL\n", sizeof_int64);
 328     printf("#define JS_BYTES_PER_LONG   %dL\n", sizeof_long);
 329     printf("#define JS_BYTES_PER_FLOAT  %dL\n", sizeof_float);
 330     printf("#define JS_BYTES_PER_DOUBLE %dL\n", sizeof_double);
 331     printf("#define JS_BYTES_PER_WORD   %dL\n", sizeof_word);
 332     printf("#define JS_BYTES_PER_DWORD  %dL\n", sizeof_dword);
 333     printf("\n");
 334
 335     printf("#define JS_BITS_PER_BYTE    %dL\n", bpb);
 336     printf("#define JS_BITS_PER_SHORT   %dL\n", bpb * sizeof_short);
 337     printf("#define JS_BITS_PER_INT     %dL\n", bpb * sizeof_int);
 338     printf("#define JS_BITS_PER_INT64   %dL\n", bpb * sizeof_int64);
 339     printf("#define JS_BITS_PER_LONG    %dL\n", bpb * sizeof_long);
 340     printf("#define JS_BITS_PER_FLOAT   %dL\n", bpb * sizeof_float);
 341     printf("#define JS_BITS_PER_DOUBLE  %dL\n", bpb * sizeof_double);
 342     printf("#define JS_BITS_PER_WORD    %dL\n", bpb * sizeof_word);
 343     printf("\n");
 344
 345     printf("#define JS_BITS_PER_BYTE_LOG2   %dL\n", Log2(bpb));
 346     printf("#define JS_BITS_PER_SHORT_LOG2  %dL\n", Log2(bpb * sizeof_short));
 347     printf("#define JS_BITS_PER_INT_LOG2    %dL\n", Log2(bpb * sizeof_int));
 348     printf("#define JS_BITS_PER_INT64_LOG2  %dL\n", bits_per_int64_log2);
 349     printf("#define JS_BITS_PER_LONG_LOG2   %dL\n", Log2(bpb * sizeof_long));
 350     printf("#define JS_BITS_PER_FLOAT_LOG2  %dL\n", Log2(bpb * sizeof_float));
 351     printf("#define JS_BITS_PER_DOUBLE_LOG2 %dL\n", Log2(bpb * sizeof_double));
 352     printf("#define JS_BITS_PER_WORD_LOG2   %dL\n", Log2(bpb * sizeof_word));
 353     printf("\n");
 354
 355     printf("#define JS_ALIGN_OF_SHORT   %dL\n", align_of_short);
 356     printf("#define JS_ALIGN_OF_INT     %dL\n", align_of_int);
 357     printf("#define JS_ALIGN_OF_LONG    %dL\n", align_of_long);
 358     printf("#define JS_ALIGN_OF_INT64   %dL\n", align_of_int64);
 359     printf("#define JS_ALIGN_OF_FLOAT   %dL\n", align_of_float);
 360     printf("#define JS_ALIGN_OF_DOUBLE  %dL\n", align_of_double);
 361     printf("#define JS_ALIGN_OF_POINTER %dL\n", align_of_pointer);
 362     printf("#define JS_ALIGN_OF_WORD    %dL\n", align_of_word);
 363     printf("\n");
 364
 365     printf("#define JS_BYTES_PER_WORD_LOG2   %dL\n", Log2(sizeof_word));
 366     printf("#define JS_BYTES_PER_DWORD_LOG2  %dL\n", Log2(sizeof_dword));
 367     printf("#define JS_WORDS_PER_DWORD_LOG2  %dL\n", Log2(sizeof_dword/sizeof_word));
 368     printf("\n");
 369
 370     printf("#define JS_STACK_GROWTH_DIRECTION (%d)\n", StackGrowthDirection(&dummy1));
 371     printf("\n");
 372
 373     printf("#endif /* js_cpucfg___ */\n");
 374
 375     return EXIT_SUCCESS;
 376 }
 377