*** old/src/os_cpu/solaris_sparc/vm/vm_version_solaris_sparc.cpp	Thu Sep  4 20:28:53 2014
--- new/src/os_cpu/solaris_sparc/vm/vm_version_solaris_sparc.cpp	Thu Sep  4 20:28:53 2014

*** 26,39 ****
--- 26,169 ----
  #include "memory/allocation.hpp"
  #include "memory/allocation.inline.hpp"
  #include "runtime/os.hpp"
  #include "vm_version_sparc.hpp"
  
- # include <sys/auxv.h>
- # include <sys/auxv_SPARC.h>
- # include <sys/systeminfo.h>
- # include <kstat.h>
+ #include <picl.h>
+ 
+ extern "C" static int PICL_get_l1_data_cache_line_size_helper(picl_nodehdl_t nodeh, void *result);
+ extern "C" static int PICL_get_l2_cache_line_size_helper(picl_nodehdl_t nodeh, void *result);
+ 
+ class PICL {
+   // Get a value of the integer property. The value in the tree can be either 32 or 64 bit
+   // depending on the platform. The result is converted to int.
+   static int get_int_property(picl_nodehdl_t nodeh, const char* name, int* result) {
+     picl_propinfo_t pinfo;
+     picl_prophdl_t proph;
+     if (picl_get_prop_by_name(nodeh, name, &proph) != PICL_SUCCESS ||
+         picl_get_propinfo(proph, &pinfo) != PICL_SUCCESS) {
+       return PICL_FAILURE;
+     }
+ 
+     if (pinfo.type != PICL_PTYPE_INT && pinfo.type != PICL_PTYPE_UNSIGNED_INT) {
+       assert(false, "Invalid property type");
+       return PICL_FAILURE;
+     }
+     if (pinfo.size == sizeof(int64_t)) {
+       int64_t val;
+       if (picl_get_propval(proph, &val, sizeof(int64_t)) != PICL_SUCCESS) {
+         return PICL_FAILURE;
+       }
+       *result = static_cast<int>(val);
+     } else if (pinfo.size == sizeof(int32_t)) {
+       int32_t val;
+       if (picl_get_propval(proph, &val, sizeof(int32_t)) != PICL_SUCCESS) {
+         return PICL_FAILURE;
+       }
+       *result = static_cast<int>(val);
+     } else {
+       assert(false, "Unexpected integer property size");
+       return PICL_FAILURE;
+     }
+     return PICL_SUCCESS;
+   }
+ 
+   // Visitor and a state machine that visits integer properties and verifies that the
+   // values are the same. Stores the unique value observed.
+   class UniqueValueVisitor {
+     enum {
+       INITIAL,        // Start state, no assignments happened
+       ASSIGNED,       // Assigned a value
+       INCONSISTENT    // Inconsistent value seen
+     } _state;
+     int _value;
+   public:
+     UniqueValueVisitor() : _state(INITIAL) { }
+     int value() {
+       assert(_state == ASSIGNED, "Precondition");
+       return _value;
+     }
+     void set_value(int value) {
+       assert(_state == INITIAL, "Precondition");
+       _value = value;
+       _state = ASSIGNED;
+     }
+     bool is_initial()       { return _state == INITIAL;      }
+     bool is_assigned()      { return _state == ASSIGNED;     }
+     bool is_inconsistent()  { return _state == INCONSISTENT; }
+     void set_inconsistent() { _state = INCONSISTENT;         }
+ 
+     static int visit(picl_nodehdl_t nodeh, const char* name, void *arg) {
+       UniqueValueVisitor *state = static_cast<UniqueValueVisitor*>(arg);
+       assert(!state->is_inconsistent(), "Precondition");
+       int curr;
+       if (PICL::get_int_property(nodeh, name, &curr) == PICL_SUCCESS) {
+         if (!state->is_assigned()) { // first iteration
+           state->set_value(curr);
+         } else if (curr != state->value()) { // following iterations
+           state->set_inconsistent();
+         }
+       }
+       if (state->is_inconsistent()) {
+         return PICL_WALK_TERMINATE;
+       }
+       return PICL_WALK_CONTINUE;
+     }
+   };
+ 
+   int _L1_data_cache_line_size;
+   int _L2_cache_line_size;
+ public:
+   static int get_l1_data_cache_line_size(picl_nodehdl_t nodeh, void *state) {
+     return UniqueValueVisitor::visit(nodeh, "l1-dcache-line-size", state);
+   }
+   static int get_l2_cache_line_size(picl_nodehdl_t nodeh, void *state) {
+     return UniqueValueVisitor::visit(nodeh, "l2-cache-line-size", state);
+   }
+ 
+   PICL() : _L1_data_cache_line_size(0), _L2_cache_line_size(0) {
+     if (picl_initialize() == PICL_SUCCESS) {
+       picl_nodehdl_t rooth;
+       if (picl_get_root(&rooth) == PICL_SUCCESS) {
+         UniqueValueVisitor state;
+         // Visit all "cpu" class instances
+         picl_walk_tree_by_class(rooth, "cpu", &state, PICL_get_l1_data_cache_line_size_helper);
+         if (state.is_initial()) { // Still initial, iteration found no values
+           // Try walk all "core" class instances, it might be a Fujitsu machine
+           picl_walk_tree_by_class(rooth, "core", &state, PICL_get_l1_data_cache_line_size_helper);
+         }
+         if (state.is_assigned()) { // Is there a value?
+           _L1_data_cache_line_size = state.value();
+         }
+ 
+         state = UniqueValueVisitor(); // reset the state, and repeat for L2 line size
+         picl_walk_tree_by_class(rooth, "cpu", &state, PICL_get_l2_cache_line_size_helper);
+         if (state.is_initial()) {
+           picl_walk_tree_by_class(rooth, "core", &state, PICL_get_l2_cache_line_size_helper);
+         }
+         if (state.is_assigned()) {
+           _L2_cache_line_size = state.value();
+         }
+       }
+       picl_shutdown();
+     }
+   }
+ 
+   unsigned int L1_data_cache_line_size() const { return _L1_data_cache_line_size; }
+   unsigned int L2_cache_line_size() const      { return _L2_cache_line_size;      }
+ };
+ 
+ extern "C" static int PICL_get_l1_data_cache_line_size_helper(picl_nodehdl_t nodeh, void *result) {
+   return PICL::get_l1_data_cache_line_size(nodeh, result);
+ }
+ extern "C" static int PICL_get_l2_cache_line_size_helper(picl_nodehdl_t nodeh, void *result) {
+   return PICL::get_l2_cache_line_size(nodeh, result);
+ }
  
  // We need to keep these here as long as we have to build on Solaris
  // versions before 10.
  #ifndef SI_ARCHITECTURE_32
  #define SI_ARCHITECTURE_32      516     /* basic 32-bit SI_ARCHITECTURE */

*** 209,215 ****
--- 339,350 ----
      assert(strcmp(implementation, "UNKNOWN") != 0,
             "unknown cpu info (changed kstat interface?)");
      kstat_close(kc);
    }
  
+   // Figure out cache line sizes using PICL
+   PICL picl;
+   _L1_data_cache_line_size = picl.L1_data_cache_line_size();
+   _L2_cache_line_size      = picl.L2_cache_line_size();
+ 
    return features;
  }