sal/typesconfig/typesconfig.c

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: typesconfig.c,v $
  10  * $Revision: 1.7 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <errno.h>
  34 #include <string.h>
  35
  36 #include <unistd.h>
  37 #include <sys/types.h>
  38
  39 #include <stdarg.h>
  40
  41 #include <signal.h>
  42 #include <setjmp.h>
  43
  44 #define printTypeSize(Type,Name)        printf( "sizeof(%s)\t\t= %d\n", Name, (int) sizeof (Type) )
  45
  46 #define isSignedType(Type)      (((Type)-1) < 0)
  47 #define printTypeSign(Type,Name)        printf( "%s\t\t= %s %s\n", Name, ( isSignedType(Type) ? "signed" : "unsigned" ), Name )
  48
  49
  50 /*************************************************************************
  51 |*
  52 |*      IsBigEndian()
  53 |*
  54 |*      Beschreibung            True, wenn CPU BigEndian ist
  55 |*
  56 |*      Ersterstellung          EG 26.06.96
  57 |*      Letzte Aenderung
  58 |*
  59 *************************************************************************/
  60 int IsBigEndian()
  61 {
  62   long l = 1;
  63   return ! *(char*)&l;
  64 }
  65
  66 /*************************************************************************
  67 |*
  68 |*      Typdeclarations for memory access test functions
  69 |*
  70 *************************************************************************/
  71 typedef enum { t_char, t_short, t_int, t_long, t_double } Type;
  72 typedef int (*TestFunc)( Type, void* );
  73
  74
  75 /*************************************************************************
  76 |*
  77 |*      PrintArgs()
  78 |*
  79 |*      Beschreibung            Testfunktion fuer variable Parameter
  80 |*
  81 |*      Ersterstellung          EG 26.06.96
  82 |*      Letzte Aenderung
  83 |*
  84 *************************************************************************/
  85 void PrintArgs( int p, ... )
  86 {
  87     int value;
  88     va_list ap;
  89
  90     va_start( ap, p );
  91
  92     printf( "value = %d", p );
  93
  94     while ( ( value = va_arg(ap, int) ) != 0 )
  95       printf( " %d", value );
  96
  97     printf( "\n" );
  98     va_end(ap);
  99 }
 100
 101 /*************************************************************************
 102 |*
 103 |*      SignalHdl()
 104 |*
 105 |*      Beschreibung            faengt SIGBUS und SIGSEGV in check() ab
 106 |*
 107 |*      Ersterstellung          EG 26.06.96
 108 |*      Letzte Aenderung
 109 |*
 110 *************************************************************************/
 111
 112 static sigjmp_buf jmpbuf;
 113 static volatile sig_atomic_t hit;
 114
 115 void SignalHdl( int sig )
 116 {
 117     (void) sig; // ignored
 118     hit = 1;
 119     siglongjmp(jmpbuf, 0);
 120 }
 121
 122 /*************************************************************************
 123 |*
 124 |*      check()
 125 |*
 126 |*      Beschreibung            Testet MemoryZugriff (read/write)
 127 |*
 128 |*      Ersterstellung          EG 26.06.96
 129 |*      Letzte Aenderung
 130 |*
 131 *************************************************************************/
 132 int check( TestFunc func, Type eT, void* p )
 133 {
 134     hit = 0;
 135     if (sigsetjmp(jmpbuf, 1) == 0) {
 136         struct sigaction sa;
 137         sa.sa_handler = SignalHdl;
 138         sigemptyset(&sa.sa_mask);
 139         sa.sa_flags = 0;
 140         if (sigaction(SIGBUS, &sa, NULL) != 0 ||
 141             sigaction(SIGSEGV, &sa, NULL) != 0)
 142         {
 143             abort();
 144         }
 145         func(eT, p);
 146         sa.sa_handler = SIG_DFL;
 147         if (sigaction(SIGBUS, &sa, NULL) != 0 ||
 148             sigaction(SIGSEGV, &sa, NULL) != 0)
 149         {
 150             abort();
 151         }
 152     }
 153     return hit ? -1 : 0;
 154 }
 155
 156 /*************************************************************************
 157 |*
 158 |*      GetAtAddress()
 159 |*
 160 |*      Beschreibung            memory read access
 161 |*
 162 |*      Ersterstellung          EG 26.06.96
 163 |*      Letzte Aenderung
 164 |*
 165 *************************************************************************/
 166 #if defined(IA64) || defined(ARM32)
 167
 168 int forceerror()
 169 {
 170 #if defined(ARM32)
 171 // workaround for qemu-user
 172     hit = 1;
 173 #else
 174     raise (SIGBUS);
 175 #endif
 176     return 1;
 177 }
 178
 179 int GetAtAddress( Type eT, void* p )
 180 {
 181   switch ( eT )
 182   {
 183   case t_char:          return *((char*)p);
 184   case t_short:         if ((long)p % sizeof(short)) return forceerror(); else return *((short*)p);
 185   case t_int:           if ((long)p % sizeof(int)) return forceerror(); else return *((int*)p);
 186   case t_long:          if ((long)p % sizeof(long)) return forceerror(); else return *((long*)p);
 187   case t_double:        if ((long)p % sizeof(double)) return forceerror(); else return *((double*)p);
 188   }
 189   abort();
 190 }
 191
 192 #else
 193 static int dummy(void* unused);
 194
 195 int GetAtAddress( Type eT, void* p )
 196 {
 197   switch ( eT )
 198   {
 199   case t_char: { char x = *(char*)p; return dummy(&x); }
 200   case t_short: { short x = *(short*)p; return dummy(&x); }
 201   case t_int: { int x = *(int*)p; return dummy(&x); }
 202   case t_long: { long x = *(long*)p; return dummy(&x); }
 203   case t_double: { double x = *(double*)p; return dummy(&x); }
 204   }
 205   abort();
 206 }
 207
 208 int dummy(void* unused)
 209 {
 210     (void)unused;
 211     return 0;
 212 }
 213
 214 #endif
 215 /*************************************************************************
 216 |*
 217 |*      SetAtAddress()
 218 |*
 219 |*      Beschreibung            memory write access
 220 |*
 221 |*      Ersterstellung          EG 26.06.96
 222 |*      Letzte Aenderung
 223 |*
 224 *************************************************************************/
 225 int SetAtAddress( Type eT, void* p )
 226 {
 227   switch ( eT )
 228   {
 229   case t_char:          return *((char*)p)      = 0;
 230   case t_short:         return *((short*)p)     = 0;
 231   case t_int:           return *((int*)p)       = 0;
 232   case t_long:          return *((long*)p)      = 0;
 233   case t_double:        return *((double*)p)= 0;
 234   }
 235   abort();
 236 }
 237
 238 char* TypeName( Type eT )
 239 {
 240   switch ( eT )
 241   {
 242   case t_char:          return "char";
 243   case t_short:         return "short";
 244   case t_int:           return "int";
 245   case t_long:          return "long";
 246   case t_double:        return "double";
 247   }
 248   abort();
 249 }
 250
 251 /*************************************************************************
 252 |*
 253 |*      Check(Get|Set)Access()
 254 |*
 255 |*      Beschreibung            Testet MemoryZugriff (read/write)
 256 |*                                              Zugriffsverletzungen werden abgefangen
 257 |*
 258 |*      Ersterstellung          EG 26.06.96
 259 |*      Letzte Aenderung
 260 |*
 261 *************************************************************************/
 262 int CheckGetAccess( Type eT, void* p )
 263 {
 264   int b;
 265   b = -1 != check( (TestFunc)GetAtAddress, eT, p );
 266 #if OSL_DEBUG_LEVEL > 1
 267   fprintf( stderr,
 268            "%s read %s at %p\n",
 269            (b? "can" : "can not" ), TypeName(eT), p );
 270 #endif
 271   return b;
 272 }
 273 int CheckSetAccess( Type eT, void* p )
 274 {
 275   int b;
 276
 277   b = -1 != check( (TestFunc)SetAtAddress, eT, p );
 278 #if OSL_DEBUG_LEVEL > 1
 279   fprintf( stderr,
 280            "%s write %s at %p\n",
 281            (b? "can" : "can not" ), TypeName(eT), p );
 282 #endif
 283   return b;
 284 }
 285
 286 /*************************************************************************
 287 |*
 288 |*      GetAlignment()
 289 |*
 290 |*      Beschreibung            Bestimmt das Alignment verschiedener Typen
 291 |*
 292 |*      Ersterstellung          EG 26.06.96
 293 |*      Letzte Aenderung
 294 |*
 295 *************************************************************************/
 296 int GetAlignment( Type eT )
 297 {
 298   char  a[ 16*8 ];
 299   long  p = (long)(void*)a;
 300   int   i;
 301
 302   /* clear a[...] to set legal value for double access */
 303   for ( i = 0; i < 16*8; i++ )
 304     a[i] = 0;
 305
 306   p = ( p + 0xF ) & ~0xF;
 307   for ( i = 1; i < 16; i++ )
 308     if ( CheckGetAccess( eT, (void*)(p+i) ) )
 309       return i;
 310   return 0;
 311 }
 312
 313 /*************************************************************************
 314 |*
 315 |*      struct Description
 316 |*
 317 |*      Beschreibung            Beschreibt die Parameter der Architektur
 318 |*
 319 |*      Ersterstellung          EG 26.06.96
 320 |*      Letzte Aenderung
 321 |*
 322 *************************************************************************/
 323 struct Description
 324 {
 325   int   bBigEndian;
 326   int   nAlignment[3];  /* 2,4,8 */
 327 };
 328
 329 /*************************************************************************
 330 |*
 331 |*      Description_Ctor()
 332 |*
 333 |*      Beschreibung            Bestimmt die Parameter der Architektur
 334 |*
 335 |*      Ersterstellung          EG 26.06.96
 336 |*      Letzte Aenderung
 337 |*
 338 *************************************************************************/
 339 void Description_Ctor( struct Description* pThis )
 340 {
 341   pThis->bBigEndian                     = IsBigEndian();
 342
 343   if ( sizeof(short) != 2 )
 344     abort();
 345   pThis->nAlignment[0] = GetAlignment( t_short );
 346   if ( sizeof(int) != 4 )
 347     abort();
 348   pThis->nAlignment[1] = GetAlignment( t_int );
 349
 350   if      ( sizeof(long) == 8 )
 351     pThis->nAlignment[2] = GetAlignment( t_long );
 352   else if ( sizeof(double) == 8 )
 353     pThis->nAlignment[2] = GetAlignment( t_double );
 354   else
 355     abort();
 356 }
 357
 358 /*************************************************************************
 359 |*
 360 |*      Description_Print()
 361 |*
 362 |*      Beschreibung            Schreibt die Parameter der Architektur als Header
 363 |*
 364 |*      Ersterstellung          EG 26.06.96
 365 |*      Letzte Aenderung
 366 |*
 367 *************************************************************************/
 368 void Description_Print( struct Description* pThis, char* name )
 369 {
 370   int i;
 371   FILE* f = fopen( name, "w" );
 372   if( ! f ) {
 373       fprintf( stderr, "Unable to open file %s: %s\n", name, strerror( errno ) );
 374       exit( 99 );
 375   }
 376   fprintf( f, "/* This file is autogenerated from the 'typesconfig' program\n * in the sal module\n */\n\n" );
 377
 378 /* Disabled for now in preference to big/little endian defines in <osl/endian.h>  fa (2004-03-15) */
 379 /*  fprintf( f, "#define SAL_TYPES_%s\n", pThis->bBigEndian ? "BIGENDIAN" : "LITTLEENDIAN" ); */
 380
 381   for ( i = 0; i < 3; i++ )
 382     fprintf( f, "#define SAL_TYPES_ALIGNMENT%d\t%d\n",  1 << (i+1), pThis->nAlignment[i] );
 383   fprintf( f, "#define SAL_TYPES_SIZEOFSHORT\t%d\n", (int) sizeof( short ) );
 384   fprintf( f, "#define SAL_TYPES_SIZEOFINT\t%d\n", (int) sizeof( int ) );
 385   fprintf( f, "#define SAL_TYPES_SIZEOFLONG\t%d\n", (int) sizeof( long ) );
 386   fprintf( f, "#define SAL_TYPES_SIZEOFLONGLONG\t%d\n", (int) sizeof( long long ) );
 387   fprintf( f, "#define SAL_TYPES_SIZEOFPOINTER\t%d\n", (int) sizeof( void* ) );
 388
 389 /* Disabled for now, becuase OOo code assumes sizeof(double) == 8 and this is not
 390  * likely to change any time soon.  fa (2004-03-15)
 391  */
 392 /*  fprintf( f, "#define SAL_TYPES_SIZEOFDOUBLE\t%d\n", sizeof( double ) );*/
 393
 394   fclose( f );
 395 }
 396
 397 /*************************************************************************
 398 |*
 399 |*      InfoMemoryAccess()
 400 |*
 401 |*      Beschreibung            Informeller Bytezugriffstest
 402 |*
 403 |*      Ersterstellung          EG 26.06.96
 404 |*      Letzte Aenderung
 405 |*
 406 *************************************************************************/
 407 void InfoMemoryAccess( char* p )
 408 {
 409   if ( CheckGetAccess( t_char, p ) )
 410     printf( "can read address %p\n", p );
 411   else
 412     printf( "cannot read address %p\n", p );
 413
 414   if ( CheckSetAccess( t_char, p ) )
 415     printf( "can write address %p\n", p );
 416   else
 417     printf( "cannot write address %p\n", p );
 418 }
 419
 420 /*************************************************************************
 421 |*
 422 |*      InfoMemoryTypeAccess()
 423 |*
 424 |*      Beschreibung            Informeller Zugriffstest verschiedener Typen
 425 |*
 426 |*      Ersterstellung          EG 15.08.96
 427 |*      Letzte Aenderung
 428 |*
 429 *************************************************************************/
 430 void InfoMemoryTypeAccess( Type eT )
 431 {
 432   char  a[64];
 433   int   i;
 434
 435   /* clear a[...] to set legal value for double access */
 436   for ( i = 0; i < 64; i++ )
 437     a[i] = 0;
 438
 439   for ( i = 56; i >= 7; i >>= 1 )
 440   {
 441     if ( CheckGetAccess(eT, (long*)&a[i]) )
 442         printf( "Access %s on %i-Aligned Address : OK\n", TypeName(eT), i / 7 );
 443     else
 444         printf( "Access %s on %i-Aligned Address : ERROR\n", TypeName(eT), i / 7 );
 445   }
 446 }
 447 /************************************************************************
 448  *
 449  *      Use C code to determine the characteristics of the building platform.
 450  *
 451  ************************************************************************/
 452 int main( int argc, char* argv[] )
 453 {
 454   printTypeSign( char, "char" );
 455   printTypeSign( short, "short" );
 456   printTypeSign( int, "int" );
 457   printTypeSign( long, "long" );
 458   printTypeSign( long long, "long long" );
 459
 460   printTypeSize( short, "short" );
 461   printTypeSize( int, "int" );
 462   printTypeSize( long, "long" );
 463   printTypeSize( long long, "long long" );
 464   printTypeSize( float, "float" );
 465   printTypeSize( double, "double" );
 466   printTypeSize( void *, "void *" );
 467
 468   if ( IsBigEndian() )
 469     printf( "BIGENDIAN (Sparc, RS6000, IP22, IP32, PowerPC(BE))\n" );
 470   else
 471     printf( "LITTLEENDIAN (Intel, x86-64, PowerPC(LE))\n" );
 472
 473   /* PrintArgs( 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 ); */
 474
 475   if ( argc > 1 )
 476   {
 477     struct Description description;
 478     Description_Ctor( &description );
 479     Description_Print( &description, argv[1] );
 480   }
 481   {
 482     char* p = NULL;
 483     InfoMemoryAccess( p );
 484     p = (char*)&p;
 485     InfoMemoryAccess( p );
 486     InfoMemoryTypeAccess( t_short );
 487     InfoMemoryTypeAccess( t_int );
 488     InfoMemoryTypeAccess( t_long );
 489     InfoMemoryTypeAccess( t_double );
 490   }
 491
 492   exit( 0 );
 493 }