tools/source/solar/solar.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: solar.c,v $
  10  * $Revision: 1.6 $
  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 /* POSIX defines that a program is undefined after a SIG_SEGV.  The
  32  * code stopped working on Linux Kernel 2.6 so I have moved this back to
  33  * use FORK.
  34  * If at a later time the signals work correctly with the Linux Kernel 2.6
  35  * then this change may be reverted although not strictly posix safe. */
  36 #define USE_FORK_TO_CHECK 1
  37
  38 #include <stdio.h>
  39 #include <stdlib.h>
  40 #include <errno.h>
  41 #include <string.h>
  42
  43 #include <unistd.h>
  44 #include <sys/types.h>
  45
  46 #define I_STDARG
  47 #ifdef I_STDARG
  48 #include <stdarg.h>
  49 #else
  50 #include <varargs.h>
  51 #endif
  52
  53 #define NO_USE_FORK_TO_CHECK
  54 #ifdef USE_FORK_TO_CHECK
  55 #include <sys/wait.h>
  56 #else
  57 #include <signal.h>
  58 #include <setjmp.h>
  59 #endif
  60
  61 #define printTypeSize(Type,Name)        printf( "sizeof(%s)\t= %d\n", Name, sizeof (Type) )
  62
  63 #define isSignedType(Type)      (((Type)-1) < 0)
  64 #define printTypeSign(Type,Name)        printf( "%s\t= %s %s\n", Name, ( isSignedType(Type) ? "signed" : "unsigned" ), Name )
  65
  66
  67 /*************************************************************************
  68 |*
  69 |*      IsBigEndian()
  70 |*
  71 |*      Beschreibung            True, wenn CPU BigEndian ist
  72 |*
  73 |*      Ersterstellung          EG 26.06.96
  74 |*      Letzte Aenderung
  75 |*
  76 *************************************************************************/
  77 int IsBigEndian()
  78 {
  79   long l = 1;
  80   return ! *(char*)&l;
  81 }
  82
  83 /*************************************************************************
  84 |*
  85 |*      IsStackGrowingDown()
  86 |*
  87 |*      Beschreibung            True, wenn der Stack nach unten waechst
  88 |*
  89 |*      Ersterstellung          EG 26.06.96
  90 |*      Letzte Aenderung
  91 |*
  92 *************************************************************************/
  93 int IsStackGrowingDown_2( int * pI )
  94 {
  95   int i = 1;
  96   return ((unsigned long)&i) < (unsigned long)pI;
  97 }
  98
  99 int IsStackGrowingDown()
 100 {
 101   int i = 1;
 102   return IsStackGrowingDown_2(&i);
 103 }
 104
 105 /*************************************************************************
 106 |*
 107 |*      GetStackAlignment()
 108 |*
 109 |*      Beschreibung            Alignment von char Parametern, die (hoffentlich)
 110 |*                                              ueber den Stack uebergeben werden
 111 |*
 112 |*      Ersterstellung          EG 26.06.96
 113 |*      Letzte Aenderung
 114 |*
 115 *************************************************************************/
 116 int GetStackAlignment_3( char*p, long l, int i, short s, char b, char c, ... )
 117 {
 118   if ( IsStackGrowingDown() )
 119     return &c - &b;
 120   else
 121     return &b - &c;
 122 }
 123
 124 int GetStackAlignment_2( char*p, long l, int i, short s, char b, char c )
 125 {
 126   if ( IsStackGrowingDown() )
 127     return &c - &b;
 128   else
 129     return &b - &c;
 130 }
 131
 132 int GetStackAlignment()
 133 {
 134   int nStackAlignment = GetStackAlignment_3(0,1,2,3,4,5);
 135   if ( nStackAlignment != GetStackAlignment_2(0,1,2,3,4,5) )
 136     printf( "Pascal calling convention\n" );
 137   return nStackAlignment;
 138 }
 139
 140
 141 /*************************************************************************
 142 |*
 143 |*      Typdeclarations for memory access test functions
 144 |*
 145 *************************************************************************/
 146 typedef enum { t_char, t_short, t_int, t_long, t_double } Type;
 147 typedef int (*TestFunc)( Type, void* );
 148
 149
 150 /*************************************************************************
 151 |*
 152 |*      PrintArgs()
 153 |*
 154 |*      Beschreibung            Testfunktion fuer variable Parameter
 155 |*
 156 |*      Ersterstellung          EG 26.06.96
 157 |*      Letzte Aenderung
 158 |*
 159 *************************************************************************/
 160 #ifdef I_STDARG
 161 void PrintArgs( int p, ... )
 162 #else
 163 void PrintArgs( p, va_alist )
 164 int p;
 165 va_dcl
 166 #endif
 167 {
 168     int value;
 169     va_list ap;
 170
 171 #ifdef I_STDARG
 172     va_start( ap, p );
 173 #else
 174     va_start( ap );
 175 #endif
 176
 177     printf( "value = %d", p );
 178
 179     while ( ( value = va_arg(ap, int) ) != 0 )
 180       printf( " %d", value );
 181
 182     printf( "\n" );
 183     va_end(ap);
 184 }
 185
 186 #ifndef USE_FORK_TO_CHECK
 187 /*************************************************************************
 188 |*
 189 |*      SignalHdl()
 190 |*
 191 |*      Beschreibung            faengt SIGBUS und SIGSEGV in check() ab
 192 |*
 193 |*      Ersterstellung          EG 26.06.96
 194 |*      Letzte Aenderung
 195 |*
 196 *************************************************************************/
 197 static jmp_buf check_env;
 198 static int bSignal;
 199 void SignalHdl( int sig )
 200 {
 201   bSignal = 1;
 202
 203   fprintf( stderr, "Signal %d caught\n", sig );
 204   signal( SIGSEGV,      SIG_DFL );
 205   signal( SIGBUS,       SIG_DFL );
 206   siglongjmp( check_env, sig );
 207 }
 208 #endif
 209
 210 /*************************************************************************
 211 |*
 212 |*      check()
 213 |*
 214 |*      Beschreibung            Testet MemoryZugriff (read/write)
 215 |*
 216 |*      Ersterstellung          EG 26.06.96
 217 |*      Letzte Aenderung
 218 |*
 219 *************************************************************************/
 220 int check( TestFunc func, Type eT, void* p )
 221 {
 222 #ifdef USE_FORK_TO_CHECK
 223   pid_t nChild = fork();
 224   if ( nChild )
 225   {
 226     int exitVal;
 227     wait( &exitVal );
 228     if ( exitVal & 0xff )
 229       return -1;
 230     else
 231       return exitVal >> 8;
 232   }
 233   else
 234   {
 235     exit( func( eT, p ) );
 236   }
 237 #else
 238   int result;
 239
 240   bSignal = 0;
 241
 242   if ( !sigsetjmp( check_env, 1 ) )
 243   {
 244     signal( SIGSEGV,    SignalHdl );
 245     signal( SIGBUS,             SignalHdl );
 246     result = func( eT, p );
 247     signal( SIGSEGV,    SIG_DFL );
 248     signal( SIGBUS,             SIG_DFL );
 249   }
 250
 251   if ( bSignal )
 252     return -1;
 253   else
 254     return 0;
 255 #endif
 256 }
 257
 258 /*************************************************************************
 259 |*
 260 |*      GetAtAddress()
 261 |*
 262 |*      Beschreibung            memory read access
 263 |*
 264 |*      Ersterstellung          EG 26.06.96
 265 |*      Letzte Aenderung
 266 |*
 267 *************************************************************************/
 268 int GetAtAddress( Type eT, void* p )
 269 {
 270   switch ( eT )
 271   {
 272   case t_char:          return *((char*)p);
 273   case t_short:         return *((short*)p);
 274   case t_int:           return *((int*)p);
 275   case t_long:          return *((long*)p);
 276   case t_double:        return *((double*)p);
 277   }
 278   abort();
 279 }
 280
 281 /*************************************************************************
 282 |*
 283 |*      SetAtAddress()
 284 |*
 285 |*      Beschreibung            memory write access
 286 |*
 287 |*      Ersterstellung          EG 26.06.96
 288 |*      Letzte Aenderung
 289 |*
 290 *************************************************************************/
 291 int SetAtAddress( Type eT, void* p )
 292 {
 293   switch ( eT )
 294   {
 295   case t_char:          return *((char*)p)      = 0;
 296   case t_short:         return *((short*)p)     = 0;
 297   case t_int:           return *((int*)p)       = 0;
 298   case t_long:          return *((long*)p)      = 0;
 299   case t_double:        return *((double*)p)= 0;
 300   }
 301   abort();
 302 }
 303
 304 char* TypeName( Type eT )
 305 {
 306   switch ( eT )
 307   {
 308   case t_char:          return "char";
 309   case t_short:         return "short";
 310   case t_int:           return "int";
 311   case t_long:          return "long";
 312   case t_double:        return "double";
 313   }
 314   abort();
 315 }
 316
 317 /*************************************************************************
 318 |*
 319 |*      Check(Get|Set)Access()
 320 |*
 321 |*      Beschreibung            Testet MemoryZugriff (read/write)
 322 |*                                              Zugriffsverletzungen werden abgefangen
 323 |*
 324 |*      Ersterstellung          EG 26.06.96
 325 |*      Letzte Aenderung
 326 |*
 327 *************************************************************************/
 328 int CheckGetAccess( Type eT, void* p )
 329 {
 330   int b;
 331   b = -1 != check( (TestFunc)GetAtAddress, eT, p );
 332 #if OSL_DEBUG_LEVEL > 1
 333   fprintf( stderr,
 334            "%s read %s at %p\n",
 335            (b? "can" : "can not" ), TypeName(eT), p );
 336 #endif
 337   return b;
 338 }
 339 int CheckSetAccess( Type eT, void* p )
 340 {
 341   int b;
 342
 343   b = -1 != check( (TestFunc)SetAtAddress, eT, p );
 344 #if OSL_DEBUG_LEVEL > 1
 345   fprintf( stderr,
 346            "%s write %s at %p\n",
 347            (b? "can" : "can not" ), TypeName(eT), p );
 348 #endif
 349   return b;
 350 }
 351
 352 /*************************************************************************
 353 |*
 354 |*      GetAlignment()
 355 |*
 356 |*      Beschreibung            Bestimmt das Alignment verschiedener Typen
 357 |*
 358 |*      Ersterstellung          EG 26.06.96
 359 |*      Letzte Aenderung
 360 |*
 361 *************************************************************************/
 362 int GetAlignment( Type eT )
 363 {
 364   char  a[ 16*8 ];
 365   long  p = (long)(void*)a;
 366   int   i;
 367
 368   /* clear a[...] to set legal value for double access */
 369   for ( i = 0; i < 16*8; i++ )
 370     a[i] = 0;
 371
 372   p = ( p + 0xF ) & ~0xF;
 373   for ( i = 1; i < 16; i++ )
 374     if ( CheckGetAccess( eT, (void*)(p+i) ) )
 375       return i;
 376   return 0;
 377 }
 378
 379 /*************************************************************************
 380 |*
 381 |*      struct Description
 382 |*
 383 |*      Beschreibung            Beschreibt die Parameter der Architektur
 384 |*
 385 |*      Ersterstellung          EG 26.06.96
 386 |*      Letzte Aenderung
 387 |*
 388 *************************************************************************/
 389 struct Description
 390 {
 391   int   bBigEndian;
 392   int   bStackGrowsDown;
 393   int   nStackAlignment;
 394   int   nAlignment[3];  /* 2,4,8 */
 395 };
 396
 397 /*************************************************************************
 398 |*
 399 |*      Description_Ctor()
 400 |*
 401 |*      Beschreibung            Bestimmt die Parameter der Architektur
 402 |*
 403 |*      Ersterstellung          EG 26.06.96
 404 |*      Letzte Aenderung
 405 |*
 406 *************************************************************************/
 407 void Description_Ctor( struct Description* pThis )
 408 {
 409   pThis->bBigEndian                     = IsBigEndian();
 410   pThis->bStackGrowsDown        = IsStackGrowingDown();
 411   pThis->nStackAlignment        = GetStackAlignment();
 412
 413   if ( sizeof(short) != 2 )
 414     abort();
 415   pThis->nAlignment[0] = GetAlignment( t_short );
 416   if ( sizeof(int) != 4 )
 417     abort();
 418   pThis->nAlignment[1] = GetAlignment( t_int );
 419
 420   if      ( sizeof(long) == 8 )
 421     pThis->nAlignment[2] = GetAlignment( t_long );
 422   else if ( sizeof(double) == 8 )
 423     pThis->nAlignment[2] = GetAlignment( t_double );
 424   else
 425     abort();
 426 }
 427
 428 /*************************************************************************
 429 |*
 430 |*      Description_Print()
 431 |*
 432 |*      Beschreibung            Schreibt die Parameter der Architektur als Header
 433 |*
 434 |*      Ersterstellung          EG 26.06.96
 435 |*      Letzte Aenderung
 436 |*
 437 *************************************************************************/
 438 void Description_Print( struct Description* pThis, char* name )
 439 {
 440   int i;
 441   FILE* f = fopen( name, "w" );
 442   if( ! f ) {
 443       fprintf( stderr, "Unable to open file %s: %s\n", name, strerror( errno ) );
 444       exit( 99 );
 445   }
 446   fprintf( f, "#define __%s\n",
 447            pThis->bBigEndian ? "BIGENDIAN" : "LITTLEENDIAN" );
 448   for ( i = 0; i < 3; i++ )
 449     fprintf( f, "#define __ALIGNMENT%d\t%d\n",
 450              1 << (i+1), pThis->nAlignment[i] );
 451   fprintf( f, "/* Stack alignment is not used... */\n" );
 452   fprintf( f, "#define __STACKALIGNMENT\t%d\n", pThis->nStackAlignment );
 453   fprintf( f, "#define __STACKDIRECTION\t%d\n",
 454            pThis->bStackGrowsDown ? -1 : 1 );
 455   fprintf( f, "#define __SIZEOFCHAR\t%d\n", sizeof( char ) );
 456   fprintf( f, "#define __SIZEOFSHORT\t%d\n", sizeof( short ) );
 457   fprintf( f, "#define __SIZEOFINT\t%d\n", sizeof( int ) );
 458   fprintf( f, "#define __SIZEOFLONG\t%d\n", sizeof( long ) );
 459   fprintf( f, "#define __SIZEOFPOINTER\t%d\n", sizeof( void* ) );
 460   fprintf( f, "#define __SIZEOFDOUBLE\t%d\n", sizeof( double ) );
 461   fprintf( f, "#define __IEEEDOUBLE\n" );
 462   fclose( f );
 463 }
 464
 465 /*************************************************************************
 466 |*
 467 |*      InfoMemoryAccess()
 468 |*
 469 |*      Beschreibung            Informeller Bytezugriffstest
 470 |*
 471 |*      Ersterstellung          EG 26.06.96
 472 |*      Letzte Aenderung
 473 |*
 474 *************************************************************************/
 475 void InfoMemoryAccess( char* p )
 476 {
 477   if ( CheckGetAccess( t_char, p ) )
 478     printf( "can read address %p\n", p );
 479   else
 480     printf( "can not read address %p\n", p );
 481
 482   if ( CheckSetAccess( t_char, p ) )
 483     printf( "can write address %p\n", p );
 484   else
 485     printf( "can not write address %p\n", p );
 486 }
 487
 488 /*************************************************************************
 489 |*
 490 |*      InfoMemoryTypeAccess()
 491 |*
 492 |*      Beschreibung            Informeller Zugriffstest verschiedener Typen
 493 |*
 494 |*      Ersterstellung          EG 15.08.96
 495 |*      Letzte Aenderung
 496 |*
 497 *************************************************************************/
 498 void InfoMemoryTypeAccess( Type eT )
 499 {
 500   char  a[64];
 501   int   i;
 502
 503   /* clear a[...] to set legal value for double access */
 504   for ( i = 0; i < 64; i++ )
 505     a[i] = 0;
 506
 507   for ( i = 56; i >= 7; i >>= 1 )
 508   {
 509     printf( "Zugriff %s auf %i-Aligned Adresse : ", TypeName( eT ), i / 7 );
 510     printf( ( CheckGetAccess( eT, (long*)&a[i] ) ? "OK\n" : "ERROR\n" ) );
 511   }
 512 }
 513 /************************************************************************
 514  *
 515  *      Use C code to determine the characteristics of the building platform.
 516  *
 517  ************************************************************************/
 518 int main( int argc, char* argv[] )
 519 {
 520   printTypeSign( char, "char" );
 521   printTypeSign( short, "short" );
 522   printTypeSign( int, "int" );
 523   printTypeSign( long, "long" );
 524
 525   printTypeSize( char, "char" );
 526   printTypeSize( short, "short" );
 527   printTypeSize( int, "int" );
 528   printTypeSize( long, "long" );
 529   printTypeSize( float, "float" );
 530   printTypeSize( double, "double" );
 531   printTypeSize( void *, "void *" );
 532
 533   if ( IsBigEndian() )
 534     printf( "BIGENDIAN (Sparc, MC680x0, RS6000, IP22, IP32, g3)\n" );
 535   else
 536     printf( "LITTLEENDIAN (Intel, VAX, PowerPC)\n" );
 537
 538   if( IsStackGrowingDown() )
 539     printf( "Stack waechst nach unten\n" );
 540   else
 541     printf( "Stack waechst nach oben\n" );
 542
 543   printf( "STACKALIGNMENT   : %d\n", GetStackAlignment() );
 544
 545   /* PrintArgs( 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 ); */
 546
 547   if ( argc > 1 )
 548   {
 549     struct Description description;
 550     Description_Ctor( &description );
 551     Description_Print( &description, argv[1] );
 552   }
 553   {
 554     char* p = NULL;
 555     InfoMemoryAccess( p );
 556     p = (char*)&p;
 557     InfoMemoryAccess( p );
 558     InfoMemoryTypeAccess( t_short );
 559     InfoMemoryTypeAccess( t_int );
 560     InfoMemoryTypeAccess( t_long );
 561     InfoMemoryTypeAccess( t_double );
 562   }
 563
 564   exit( 0 );
 565 }