jdk8-mips64-public/hotspot: src/cpu/sparc/vm/vm_version

     1 /*

     2  * Copyright 1997-2007 Sun Microsystems, Inc.  All Rights Reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    20  * CA 95054 USA or visit www.sun.com if you need additional information or

    21  * have any questions.

    22  *

    23  */

    25 class VM_Version: public Abstract_VM_Version {

    26 protected:

    27   enum Feature_Flag {

    28     v8_instructions     = 0,

    29     hardware_int_muldiv = 1,

    30     hardware_fsmuld     = 2,

    31     v9_instructions     = 3,

    32     vis1_instructions   = 4,

    33     vis2_instructions   = 5,

    34     sun4v_instructions  = 6

    35   };

    37   enum Feature_Flag_Set {

    38     unknown_m             = 0,

    39     all_features_m        = -1,

    41     v8_instructions_m     = 1 << v8_instructions,

    42     hardware_int_muldiv_m = 1 << hardware_int_muldiv,

    43     hardware_fsmuld_m     = 1 << hardware_fsmuld,

    44     v9_instructions_m     = 1 << v9_instructions,

    45     vis1_instructions_m   = 1 << vis1_instructions,

    46     vis2_instructions_m   = 1 << vis2_instructions,

    47     sun4v_m               = 1 << sun4v_instructions,

    49     generic_v8_m          = v8_instructions_m | hardware_int_muldiv_m | hardware_fsmuld_m,

    50     generic_v9_m          = generic_v8_m | v9_instructions_m | vis1_instructions_m,

    51     ultra3_m              = generic_v9_m | vis2_instructions_m,

    53     // Temporary until we have something more accurate

    54     niagara1_unique_m     = sun4v_m,

    55     niagara1_m            = generic_v9_m | niagara1_unique_m

    56   };

    58   static int  _features;

    59   static const char* _features_str;

    61   static void print_features();

    62   static int  determine_features();

    63   static int  platform_features(int features);

    65   static bool is_niagara1(int features) { return (features & niagara1_m) == niagara1_m; }

    67 public:

    68   // Initialization

    69   static void initialize();

    71   // Instruction support

    72   static bool has_v8()                  { return (_features & v8_instructions_m) != 0; }

    73   static bool has_v9()                  { return (_features & v9_instructions_m) != 0; }

    74   static bool has_hardware_int_muldiv() { return (_features & hardware_int_muldiv_m) != 0; }

    75   static bool has_hardware_fsmuld()     { return (_features & hardware_fsmuld_m) != 0; }

    76   static bool has_vis1()                { return (_features & vis1_instructions_m) != 0; }

    77   static bool has_vis2()                { return (_features & vis2_instructions_m) != 0; }

    79   static bool supports_compare_and_exchange()

    80                                         { return has_v9(); }

    82   static bool is_ultra3()               { return (_features & ultra3_m) == ultra3_m; }

    83   static bool is_sun4v()                { return (_features & sun4v_m) != 0; }

    84   static bool is_niagara1()             { return is_niagara1(_features); }

    86   static bool has_fast_fxtof()          { return has_v9() && !is_ultra3(); }

    88   static const char* cpu_features()     { return _features_str; }

    90   static intx L1_data_cache_line_size()  {

    91     return 64;  // default prefetch block size on sparc

    92   }

    94   // Prefetch

    95   static intx prefetch_copy_interval_in_bytes() {

    96     intx interval = PrefetchCopyIntervalInBytes;

    97     return interval >= 0 ? interval : (has_v9() ? 512 : 0);

    98   }

    99   static intx prefetch_scan_interval_in_bytes() {

   100     intx interval = PrefetchScanIntervalInBytes;

   101     return interval >= 0 ? interval : (has_v9() ? 512 : 0);

   102   }

   103   static intx prefetch_fields_ahead() {

   104     intx count = PrefetchFieldsAhead;

   105     return count >= 0 ? count : (is_ultra3() ? 1 : 0);

   106   }

   108   static intx allocate_prefetch_distance() {

   109     // This method should be called before allocate_prefetch_style().

   110     intx count = AllocatePrefetchDistance;

   111     if (count < 0) { // default is not defined ?

   112       count = 512;

   113     }

   114     return count;

   115   }

   116   static intx allocate_prefetch_style() {

   117     assert(AllocatePrefetchStyle >= 0, "AllocatePrefetchStyle should be positive");

   118     // Return 0 if AllocatePrefetchDistance was not defined.

   119     return AllocatePrefetchDistance > 0 ? AllocatePrefetchStyle : 0;

   120   }

   122   // Legacy

   123   static bool v8_instructions_work() { return has_v8() && !has_v9(); }

   124   static bool v9_instructions_work() { return has_v9(); }

   126   // Assembler testing

   127   static void allow_all();

   128   static void revert();

   130   // Override the Abstract_VM_Version implementation.

   131   static uint page_size_count() { return is_sun4v() ? 4 : 2; }

   132 };

src/cpu/sparc/vm/vm_version_sparc.hpp@a61af66fc99e