Merge

agent/src/share/classes/sun/jvm/hotspot/memory/SystemDictionary.java

@@ -29,27 +29,21 @@ import sun.jvm.hotspot.debugger.*;
 import sun.jvm.hotspot.oops.*;
 import sun.jvm.hotspot.runtime.*;
 import sun.jvm.hotspot.types.*;
-import sun.jvm.hotspot.types.OopField; // resolve ambiguity with oops.OopField
-
-// following needed for on-the-fly field construction:
-import sun.jvm.hotspot.types.basic.BasicOopField;
-import sun.jvm.hotspot.types.basic.BasicTypeDataBase;
 
 public class SystemDictionary {
   private static AddressField dictionaryField;
   private static AddressField sharedDictionaryField;
   private static AddressField placeholdersField;
   private static AddressField loaderConstraintTableField;
-  private static OopField javaSystemLoaderField;
+  private static sun.jvm.hotspot.types.OopField javaSystemLoaderField;
   private static int nofBuckets;
 
-  private static OopField wellKnownKlasses;
-  private static OopField objectKlassField;
-  private static OopField classLoaderKlassField;
-  private static OopField stringKlassField;
-  private static OopField systemKlassField;
-  private static OopField threadKlassField;
-  private static OopField threadGroupKlassField;
+  private static sun.jvm.hotspot.types.OopField objectKlassField;
+  private static sun.jvm.hotspot.types.OopField classLoaderKlassField;
+  private static sun.jvm.hotspot.types.OopField stringKlassField;
+  private static sun.jvm.hotspot.types.OopField systemKlassField;
+  private static sun.jvm.hotspot.types.OopField threadKlassField;
+  private static sun.jvm.hotspot.types.OopField threadGroupKlassField;
 
   static {
     VM.registerVMInitializedObserver(new Observer() {
@@ -69,20 +63,22 @@ public class SystemDictionary {
     javaSystemLoaderField = type.getOopField("_java_system_loader");
     nofBuckets = db.lookupIntConstant("SystemDictionary::_nof_buckets").intValue();
 
-    wellKnownKlasses = type.getOopField("_well_known_klasses[0]");
-    objectKlassField = findWellKnownKlass("object_klass", type, db);
-    classLoaderKlassField = findWellKnownKlass("classloader_klass", type, db);
-    stringKlassField = findWellKnownKlass("string_klass", type, db);
-    systemKlassField = findWellKnownKlass("system_klass", type, db);
-    threadKlassField = findWellKnownKlass("thread_klass", type, db);
-    threadGroupKlassField = findWellKnownKlass("threadGroup_klass", type, db);
+    objectKlassField = type.getOopField(WK_KLASS("object_klass"));
+    classLoaderKlassField = type.getOopField(WK_KLASS("classloader_klass"));
+    stringKlassField = type.getOopField(WK_KLASS("string_klass"));
+    systemKlassField = type.getOopField(WK_KLASS("system_klass"));
+    threadKlassField = type.getOopField(WK_KLASS("thread_klass"));
+    threadGroupKlassField = type.getOopField(WK_KLASS("threadGroup_klass"));
   }
 
-  private static OopField findWellKnownKlass(String indexName, Type type, TypeDataBase db) {
-    Address wkk = wellKnownKlasses.getStaticFieldAddress();
-    int index = db.lookupIntConstant("SystemDictionary::#"+indexName).intValue();
-    return new BasicOopField((BasicTypeDataBase)db, type, indexName, type,
-                             true, index * db.getAddressSize(), wkk);
+  // This WK functions must follow the definitions in systemDictionary.hpp:
+  private static String WK_KLASS(String name) {
+      //#define WK_KLASS(name) _well_known_klasses[SystemDictionary::WK_KLASS_ENUM_NAME(name)]
+      return ("_well_known_klasses[SystemDictionary::"+WK_KLASS_ENUM_NAME(name)+"]");
+  }
+  private static String WK_KLASS_ENUM_NAME(String kname) {
+      //#define WK_KLASS_ENUM_NAME(kname)    kname##_knum
+      return (kname+"_knum");
   }
 
   public Dictionary dictionary() {

src/cpu/x86/vm/x86_64.ad

@@ -8075,6 +8075,18 @@ instruct mulL_mem_imm(rRegL dst, memory src, immL32 imm, rFlagsReg cr)
   ins_pipe(ialu_reg_mem_alu0);
 %}
 
+instruct mulHiL_rReg(rdx_RegL dst, no_rax_RegL src, rax_RegL rax, rFlagsReg cr)
+%{
+  match(Set dst (MulHiL src rax));
+  effect(USE_KILL rax, KILL cr);
+
+  ins_cost(300);
+  format %{ "imulq   RDX:RAX, RAX, $src\t# mulhi" %}
+  opcode(0xF7, 0x5); /* Opcode F7 /5 */
+  ins_encode(REX_reg_wide(src), OpcP, reg_opc(src));
+  ins_pipe(ialu_reg_reg_alu0);
+%}
+
 instruct divI_rReg(rax_RegI rax, rdx_RegI rdx, no_rax_rdx_RegI div,
                    rFlagsReg cr)
 %{

src/share/vm/classfile/systemDictionary.hpp

@@ -386,7 +386,7 @@ public:
   #undef WK_KLASS_DECLARE
 
   // Local definition for direct access to the private array:
-  #define WK_KLASS(name) _well_known_klasses[WK_KLASS_ENUM_NAME(name)]
+  #define WK_KLASS(name) _well_known_klasses[SystemDictionary::WK_KLASS_ENUM_NAME(name)]
 
   static klassOop box_klass(BasicType t) {
     assert((uint)t < T_VOID+1, "range check");

src/share/vm/opto/classes.hpp

@@ -164,6 +164,7 @@ macro(MoveL2D)
 macro(MoveD2L)
 macro(MulD)
 macro(MulF)
+macro(MulHiL)
 macro(MulI)
 macro(MulL)
 macro(Multi)

src/share/vm/opto/mulnode.cpp

@@ -364,6 +364,25 @@ const Type *MulDNode::mul_ring(const Type *t0, const Type *t1) const {
   return TypeD::make( t0->getd() * t1->getd() );
 }
 
+//=============================================================================
+//------------------------------Value------------------------------------------
+const Type *MulHiLNode::Value( PhaseTransform *phase ) const {
+  // Either input is TOP ==> the result is TOP
+  const Type *t1 = phase->type( in(1) );
+  const Type *t2 = phase->type( in(2) );
+  if( t1 == Type::TOP ) return Type::TOP;
+  if( t2 == Type::TOP ) return Type::TOP;
+
+  // Either input is BOTTOM ==> the result is the local BOTTOM
+  const Type *bot = bottom_type();
+  if( (t1 == bot) || (t2 == bot) ||
+      (t1 == Type::BOTTOM) || (t2 == Type::BOTTOM) )
+    return bot;
+
+  // It is not worth trying to constant fold this stuff!
+  return TypeLong::LONG;
+}
+
 //=============================================================================
 //------------------------------mul_ring---------------------------------------
 // Supplied function returns the product of the inputs IN THE CURRENT RING.

src/share/vm/opto/mulnode.hpp

@@ -133,6 +133,16 @@ public:
   virtual uint ideal_reg() const { return Op_RegD; }
 };
 
+//-------------------------------MulHiLNode------------------------------------
+// Upper 64 bits of a 64 bit by 64 bit multiply
+class MulHiLNode : public Node {
+public:
+  MulHiLNode( Node *in1, Node *in2 ) : Node(0,in1,in2) {}
+  virtual int Opcode() const;
+  virtual const Type *Value( PhaseTransform *phase ) const;
+  const Type *bottom_type() const { return TypeLong::LONG; }
+  virtual uint ideal_reg() const { return Op_RegL; }
+};
 
 //------------------------------AndINode---------------------------------------
 // Logically AND 2 integers.  Included with the MUL nodes because it inherits

src/share/vm/opto/type.hpp

@@ -442,6 +442,7 @@ public:
 
   // Check for single integer
   int is_con() const { return _lo==_hi; }
+  bool is_con(int i) const { return is_con() && _lo == i; }
   jlong get_con() const { assert( is_con(), "" ); return _lo; }
 
   virtual bool        is_finite() const;  // Has a finite value

src/share/vm/runtime/vmStructs.cpp

@@ -453,7 +453,40 @@ static inline uint64_t cast_uint64_t(size_t x)
       static_field(SystemDictionary,            _shared_dictionary,                            Dictionary*)                          \
       static_field(SystemDictionary,            _system_loader_lock_obj,                       oop)                                  \
       static_field(SystemDictionary,            _loader_constraints,                           LoaderConstraintTable*)               \
-      static_field(SystemDictionary,            _well_known_klasses[0],                        klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(object_klass),                        klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(string_klass),                        klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(class_klass),                         klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(cloneable_klass),                     klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(classloader_klass),                   klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(serializable_klass),                  klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(system_klass),                        klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(throwable_klass),                     klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(threaddeath_klass),                   klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(error_klass),                         klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(exception_klass),                     klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(runtime_exception_klass),             klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(classNotFoundException_klass),        klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(noClassDefFoundError_klass),          klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(linkageError_klass),                  klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(ClassCastException_klass),            klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(ArrayStoreException_klass),           klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(virtualMachineError_klass),           klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(OutOfMemoryError_klass),              klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(StackOverflowError_klass),            klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(protectionDomain_klass),              klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(AccessControlContext_klass),          klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(reference_klass),                     klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(soft_reference_klass),                klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(weak_reference_klass),                klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(final_reference_klass),               klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(phantom_reference_klass),             klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(finalizer_klass),                     klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(thread_klass),                        klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(threadGroup_klass),                   klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(properties_klass),                    klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(stringBuffer_klass),                  klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(vector_klass),                        klassOop)                             \
+      static_field(SystemDictionary,            WK_KLASS(hashtable_klass),                     klassOop)                             \
       static_field(SystemDictionary,            _box_klasses[0],                               klassOop)                             \
       static_field(SystemDictionary,            _java_system_loader,                           oop)                                  \
                                                                                                                                      \
@@ -1367,13 +1400,6 @@ static inline uint64_t cast_uint64_t(size_t x)
                                                                           \
   declare_constant(SystemDictionary::_loader_constraint_size)             \
   declare_constant(SystemDictionary::_nof_buckets)                        \
-  /* these #foo numbers are enums used to index _well_known_klasses: */   \
-  declare_preprocessor_constant("SystemDictionary::#object_klass",       SystemDictionary::WK_KLASS_ENUM_NAME(object_klass)) \
-  declare_preprocessor_constant("SystemDictionary::#classloader_klass",  SystemDictionary::WK_KLASS_ENUM_NAME(classloader_klass)) \
-  declare_preprocessor_constant("SystemDictionary::#string_klass",       SystemDictionary::WK_KLASS_ENUM_NAME(string_klass)) \
-  declare_preprocessor_constant("SystemDictionary::#system_klass",       SystemDictionary::WK_KLASS_ENUM_NAME(system_klass)) \
-  declare_preprocessor_constant("SystemDictionary::#thread_klass",       SystemDictionary::WK_KLASS_ENUM_NAME(thread_klass)) \
-  declare_preprocessor_constant("SystemDictionary::#threadGroup_klass",  SystemDictionary::WK_KLASS_ENUM_NAME(threadGroup_klass)) \
                                                                           \
   /***********************************/                                   \
   /* LoaderConstraintTable constants */                                   \

src/share/vm/utilities/globalDefinitions.hpp

@@ -890,7 +890,7 @@ inline int log2_long(jlong x) {
     i++; p *= 2;
   }
   // p = 2^(i+1) && x < p (i.e., 2^i <= x < 2^(i+1))
-  // (if p = 0 then overflow occured and i = 31)
+  // (if p = 0 then overflow occured and i = 63)
   return i;
 }