gcc/config/rs6000/driver-rs6000.c

   1 /* Subroutines for the gcc driver.
   2    Copyright (C) 2007-2012 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 3, or (at your option)
   9 any later version.
  10
  11 GCC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 #include "config.h"
  21 #include "system.h"
  22 #include "coretypes.h"
  23 #include "tm.h"
  24 #include <stdlib.h>
  25
  26 #ifdef _AIX
  27 # include <sys/systemcfg.h>
  28 #endif
  29
  30 #ifdef __linux__
  31 # include <link.h>
  32 #endif
  33
  34 #if defined (__APPLE__) || (__FreeBSD__)
  35 # include <sys/types.h>
  36 # include <sys/sysctl.h>
  37 #endif
  38
  39 const char *host_detect_local_cpu (int argc, const char **argv);
  40
  41 #if GCC_VERSION >= 0
  42
  43 /* Returns parameters that describe L1_ASSOC associative cache of size
  44    L1_SIZEKB with lines of size L1_LINE, and L2_SIZEKB.  */
  45
  46 static char *
  47 describe_cache (unsigned l1_sizekb, unsigned l1_line,
  48                 unsigned l1_assoc ATTRIBUTE_UNUSED, unsigned l2_sizekb)
  49 {
  50   char l1size[1000], line[1000], l2size[1000];
  51
  52   /* At the moment, gcc middle-end does not use the information about the
  53      associativity of the cache.  */
  54
  55   sprintf (l1size, "--param l1-cache-size=%u", l1_sizekb);
  56   sprintf (line, "--param l1-cache-line-size=%u", l1_line);
  57   sprintf (l2size, "--param l2-cache-size=%u", l2_sizekb);
  58
  59   return concat (l1size, " ", line, " ", l2size, " ", NULL);
  60 }
  61
  62 #ifdef __APPLE__
  63
  64 /* Returns the description of caches on Darwin.  */
  65
  66 static char *
  67 detect_caches_darwin (void)
  68 {
  69   unsigned l1_sizekb, l1_line, l1_assoc, l2_sizekb;
  70   size_t len = 4;
  71   static int l1_size_name[2] = { CTL_HW, HW_L1DCACHESIZE };
  72   static int l1_line_name[2] = { CTL_HW, HW_CACHELINE };
  73   static int l2_size_name[2] = { CTL_HW, HW_L2CACHESIZE };
  74
  75   sysctl (l1_size_name, 2, &l1_sizekb, &len, NULL, 0);
  76   sysctl (l1_line_name, 2, &l1_line, &len, NULL, 0);
  77   sysctl (l2_size_name, 2, &l2_sizekb, &len, NULL, 0);
  78   l1_assoc = 0;
  79
  80   return describe_cache (l1_sizekb / 1024, l1_line, l1_assoc,
  81                          l2_sizekb / 1024);
  82 }
  83
  84 static const char *
  85 detect_processor_darwin (void)
  86 {
  87   unsigned int proc;
  88   size_t len = 4;
  89
  90   sysctlbyname ("hw.cpusubtype", &proc, &len, NULL, 0);
  91
  92   if (len > 0)
  93     switch (proc)
  94       {
  95       case 1:
  96         return "601";
  97       case 2:
  98         return "602";
  99       case 3:
 100         return "603";
 101       case 4:
 102       case 5:
 103         return "603e";
 104       case 6:
 105         return "604";
 106       case 7:
 107         return "604e";
 108       case 8:
 109         return "620";
 110       case 9:
 111         return "750";
 112       case 10:
 113         return "7400";
 114       case 11:
 115         return "7450";
 116       case 100:
 117         return "970";
 118       default:
 119         return "powerpc";
 120       }
 121
 122   return "powerpc";
 123 }
 124
 125 #endif /* __APPLE__ */
 126
 127 #ifdef __FreeBSD__
 128
 129 /* Returns the description of caches on FreeBSD PPC.  */
 130
 131 static char *
 132 detect_caches_freebsd (void)
 133 {
 134   unsigned l1_sizekb, l1_line, l1_assoc, l2_sizekb;
 135   size_t len = 4;
 136
 137   /* Currently, as of FreeBSD-7.0, there is only the cacheline_size
 138      available via sysctl.  */
 139   sysctlbyname ("machdep.cacheline_size", &l1_line, &len, NULL, 0);
 140
 141   l1_sizekb = 32;
 142   l1_assoc = 0;
 143   l2_sizekb = 512;
 144
 145   return describe_cache (l1_sizekb, l1_line, l1_assoc, l2_sizekb);
 146 }
 147
 148 /* Currently returns default powerpc.  */
 149 static const char *
 150 detect_processor_freebsd (void)
 151 {
 152   return "powerpc";
 153 }
 154
 155 #endif /* __FreeBSD__  */
 156
 157 #ifdef __linux__
 158
 159 /* Returns AT_PLATFORM if present, otherwise generic PowerPC.  */
 160
 161 static const char *
 162 elf_platform (void)
 163 {
 164   int fd;
 165
 166   fd = open ("/proc/self/auxv", O_RDONLY);
 167
 168   if (fd != -1)
 169     {
 170       char buf[1024];
 171       ElfW(auxv_t) *av;
 172       ssize_t n;
 173
 174       n = read (fd, buf, sizeof (buf));
 175       close (fd);
 176
 177       if (n > 0)
 178         {
 179           for (av = (ElfW(auxv_t) *) buf; av->a_type != AT_NULL; ++av)
 180             switch (av->a_type)
 181               {
 182               case AT_PLATFORM:
 183                 return (const char *) av->a_un.a_val;
 184
 185               default:
 186                 break;
 187               }
 188         }
 189     }
 190   return NULL;
 191 }
 192
 193 /* Returns AT_PLATFORM if present, otherwise generic 32.  */
 194
 195 static int
 196 elf_dcachebsize (void)
 197 {
 198   int fd;
 199
 200   fd = open ("/proc/self/auxv", O_RDONLY);
 201
 202   if (fd != -1)
 203     {
 204       char buf[1024];
 205       ElfW(auxv_t) *av;
 206       ssize_t n;
 207
 208       n = read (fd, buf, sizeof (buf));
 209       close (fd);
 210
 211       if (n > 0)
 212         {
 213           for (av = (ElfW(auxv_t) *) buf; av->a_type != AT_NULL; ++av)
 214             switch (av->a_type)
 215               {
 216               case AT_DCACHEBSIZE:
 217                 return av->a_un.a_val;
 218
 219               default:
 220                 break;
 221               }
 222         }
 223     }
 224   return 32;
 225 }
 226
 227 /* Returns the description of caches on Linux.  */
 228
 229 static char *
 230 detect_caches_linux (void)
 231 {
 232   unsigned l1_sizekb, l1_line, l1_assoc, l2_sizekb;
 233   const char *platform;
 234
 235   platform = elf_platform ();
 236
 237   if (platform != NULL)
 238     {
 239       l1_line = 128;
 240
 241       if (platform[5] == '6')
 242         /* POWER6 and POWER6x */
 243         l1_sizekb = 64;
 244       else
 245         l1_sizekb = 32;
 246     }
 247   else
 248     {
 249       l1_line = elf_dcachebsize ();
 250       l1_sizekb = 32;
 251     }
 252
 253   l1_assoc = 0;
 254   l2_sizekb = 512;
 255
 256   return describe_cache (l1_sizekb, l1_line, l1_assoc, l2_sizekb);
 257 }
 258
 259 static const char *
 260 detect_processor_linux (void)
 261 {
 262   const char *platform;
 263
 264   platform = elf_platform ();
 265
 266   if (platform != NULL)
 267     return platform;
 268   else
 269     return "powerpc";
 270 }
 271
 272 #endif /* __linux__ */
 273
 274 #ifdef _AIX
 275 /* Returns the description of caches on AIX.  */
 276
 277 static char *
 278 detect_caches_aix (void)
 279 {
 280   unsigned l1_sizekb, l1_line, l1_assoc, l2_sizekb;
 281
 282   l1_sizekb = _system_configuration.dcache_size / 1024;
 283   l1_line = _system_configuration.dcache_line;
 284   l1_assoc = _system_configuration.dcache_asc;
 285   l2_sizekb = _system_configuration.L2_cache_size / 1024;
 286
 287   return describe_cache (l1_sizekb, l1_line, l1_assoc, l2_sizekb);
 288 }
 289
 290
 291 /* Returns the processor implementation on AIX.  */
 292
 293 static const char *
 294 detect_processor_aix (void)
 295 {
 296   switch (_system_configuration.implementation)
 297     {
 298     case 0x0008:
 299       return "601";
 300
 301     case 0x0020:
 302       return "603";
 303
 304     case 0x0010:
 305       return "604";
 306
 307     case 0x0040:
 308       return "620";
 309
 310     case 0x0080:
 311       return "630";
 312
 313     case 0x0100:
 314     case 0x0200:
 315     case 0x0400:
 316       return "rs64";
 317
 318     case 0x0800:
 319       return "power4";
 320
 321     case 0x2000:
 322       if (_system_configuration.version == 0x0F0000)
 323         return "power5";
 324       else
 325         return "power5+";
 326
 327     case 0x4000:
 328       return "power6";
 329
 330     default:
 331       return "powerpc";
 332     }
 333 }
 334 #endif /* _AIX */
 335
 336
 337 /*
 338  * Array to map -mcpu=native names to the switches passed to the assembler.
 339  * This list mirrors the specs in ASM_CPU_SPEC, and any changes made here
 340  * should be made there as well.
 341  */
 342
 343 struct asm_name {
 344   const char *cpu;
 345   const char *asm_sw;
 346 };
 347
 348 static const struct asm_name asm_names[] = {
 349 #if defined (_AIX)
 350   { "power3",   "-m620" },
 351   { "power4",   "-mpwr4" },
 352   { "power5",   "-mpwr5" },
 353   { "power5+",  "-mpwr5x" },
 354   { "power6",   "-mpwr6" },
 355   { "power6x",  "-mpwr6" },
 356   { "power7",   "-mpwr7" },
 357   { "power8",   "-mpwr8" },
 358   { "powerpc",  "-mppc" },
 359   { "rs64a",    "-mppc" },
 360   { "603",      "-m603" },
 361   { "603e",     "-m603" },
 362   { "604",      "-m604" },
 363   { "604e",     "-m604" },
 364   { "620",      "-m620" },
 365   { "630",      "-m620" },
 366   { "970",      "-m970" },
 367   { "G5",       "-m970" },
 368   { NULL,       "\
 369 %{!maix64: \
 370 %{mpowerpc64: -mppc64} \
 371 %{maltivec: -m970} \
 372 %{!maltivec: %{!mpowerpc64: %(asm_default)}}}" },
 373
 374 #else
 375   { "cell",     "-mcell" },
 376   { "power3",   "-mppc64" },
 377   { "power4",   "-mpower4" },
 378   { "power5",   "%(asm_cpu_power5)" },
 379   { "power5+",  "%(asm_cpu_power5)" },
 380   { "power6",   "%(asm_cpu_power6) -maltivec" },
 381   { "power6x",  "%(asm_cpu_power6) -maltivec" },
 382   { "power7",   "%(asm_cpu_power7)" },
 383   { "power8",   "%(asm_cpu_power8)" },
 384   { "powerpc",  "-mppc" },
 385   { "rs64a",    "-mppc64" },
 386   { "401",      "-mppc" },
 387   { "403",      "-m403" },
 388   { "405",      "-m405" },
 389   { "405fp",    "-m405" },
 390   { "440",      "-m440" },
 391   { "440fp",    "-m440" },
 392   { "464",      "-m440" },
 393   { "464fp",    "-m440" },
 394   { "505",      "-mppc" },
 395   { "601",      "-m601" },
 396   { "602",      "-mppc" },
 397   { "603",      "-mppc" },
 398   { "603e",     "-mppc" },
 399   { "ec603e",   "-mppc" },
 400   { "604",      "-mppc" },
 401   { "604e",     "-mppc" },
 402   { "620",      "-mppc64" },
 403   { "630",      "-mppc64" },
 404   { "740",      "-mppc" },
 405   { "750",      "-mppc" },
 406   { "G3",       "-mppc" },
 407   { "7400",     "-mppc -maltivec" },
 408   { "7450",     "-mppc -maltivec" },
 409   { "G4",       "-mppc -maltivec" },
 410   { "801",      "-mppc" },
 411   { "821",      "-mppc" },
 412   { "823",      "-mppc" },
 413   { "860",      "-mppc" },
 414   { "970",      "-mpower4 -maltivec" },
 415   { "G5",       "-mpower4 -maltivec" },
 416   { "8540",     "-me500" },
 417   { "8548",     "-me500" },
 418   { "e300c2",   "-me300" },
 419   { "e300c3",   "-me300" },
 420   { "e500mc",   "-me500mc" },
 421   { NULL,       "\
 422 %{mpowerpc64*: -mppc64} \
 423 %{!mpowerpc64*: %(asm_default)}" },
 424 #endif
 425 };
 426
 427 /* This will be called by the spec parser in gcc.c when it sees
 428    a %:local_cpu_detect(args) construct.  Currently it will be called
 429    with either "arch" or "tune" as argument depending on if -march=native
 430    or -mtune=native is to be substituted.
 431
 432    Additionally it will be called with "asm" to select the appropriate flags
 433    for the assembler.
 434
 435    It returns a string containing new command line parameters to be
 436    put at the place of the above two options, depending on what CPU
 437    this is executed.
 438
 439    ARGC and ARGV are set depending on the actual arguments given
 440    in the spec.  */
 441 const char *
 442 host_detect_local_cpu (int argc, const char **argv)
 443 {
 444   const char *cpu = NULL;
 445   const char *cache = "";
 446   const char *options = "";
 447   bool arch;
 448   bool assembler;
 449   size_t i;
 450
 451   if (argc < 1)
 452     return NULL;
 453
 454   arch = strcmp (argv[0], "cpu") == 0;
 455   assembler = (!arch && strcmp (argv[0], "asm") == 0);
 456   if (!arch && !assembler && strcmp (argv[0], "tune"))
 457     return NULL;
 458
 459   if (! assembler)
 460     {
 461 #if defined (_AIX)
 462       cache = detect_caches_aix ();
 463 #elif defined (__APPLE__)
 464       cache = detect_caches_darwin ();
 465 #elif defined (__FreeBSD__)
 466       cache = detect_caches_freebsd ();
 467       /* FreeBSD PPC does not provide any cache information yet.  */
 468       cache = "";
 469 #elif defined (__linux__)
 470       cache = detect_caches_linux ();
 471       /* PPC Linux does not provide any cache information yet.  */
 472       cache = "";
 473 #else
 474       cache = "";
 475 #endif
 476     }
 477
 478 #if defined (_AIX)
 479   cpu = detect_processor_aix ();
 480 #elif defined (__APPLE__)
 481   cpu = detect_processor_darwin ();
 482 #elif defined (__FreeBSD__)
 483   cpu = detect_processor_freebsd ();
 484 #elif defined (__linux__)
 485   cpu = detect_processor_linux ();
 486 #else
 487   cpu = "powerpc";
 488 #endif
 489
 490   if (assembler)
 491     {
 492       for (i = 0; i < sizeof (asm_names) / sizeof (asm_names[0]); i++)
 493         {
 494           if (!asm_names[i].cpu || !strcmp (asm_names[i].cpu, cpu))
 495             return asm_names[i].asm_sw;
 496         }
 497
 498       return NULL;
 499     }
 500
 501   return concat (cache, "-m", argv[0], "=", cpu, " ", options, NULL);
 502 }
 503
 504 #else /* GCC_VERSION */
 505
 506 /* If we aren't compiling with GCC we just provide a minimal
 507    default value.  */
 508 const char *
 509 host_detect_local_cpu (int argc, const char **argv)
 510 {
 511   const char *cpu;
 512   bool arch;
 513
 514   if (argc < 1)
 515     return NULL;
 516
 517   arch = strcmp (argv[0], "cpu") == 0;
 518   if (!arch && strcmp (argv[0], "tune"))
 519     return NULL;
 520
 521   if (arch)
 522     cpu = "powerpc";
 523
 524   return concat ("-m", argv[0], "=", cpu, NULL);
 525 }
 526
 527 #endif /* GCC_VERSION */
 528