--- a/hotspot/src/share/vm/classfile/placeholders.hpp	Fri Aug 31 16:39:35 2012 -0700
+++ b/hotspot/src/share/vm/classfile/placeholders.hpp	Sat Sep 01 13:25:18 2012 -0400
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -40,7 +40,7 @@
 public:
   PlaceholderTable(int table_size);
 
-  PlaceholderEntry* new_entry(int hash, Symbol* name, oop loader, bool havesupername, Symbol* supername);
+  PlaceholderEntry* new_entry(int hash, Symbol* name, ClassLoaderData* loader_data, bool havesupername, Symbol* supername);
   void free_entry(PlaceholderEntry* entry);
 
   PlaceholderEntry* bucket(int i) {
@@ -56,14 +56,14 @@
   }
 
   void add_entry(int index, unsigned int hash, Symbol* name,
-                Handle loader, bool havesupername, Symbol* supername);
+                ClassLoaderData* loader_data, bool havesupername, Symbol* supername);
 
   // This returns a Symbol* to match type for SystemDictionary
   Symbol* find_entry(int index, unsigned int hash,
-                       Symbol* name, Handle loader);
+                       Symbol* name, ClassLoaderData* loader_data);
 
   PlaceholderEntry* get_entry(int index, unsigned int hash,
-                       Symbol* name, Handle loader);
+                       Symbol* name, ClassLoaderData* loader_data);
 
 // caller to create a placeholder entry must enumerate an action
 // caller claims ownership of that action
@@ -85,22 +85,22 @@
   // If no entry exists, add a placeholder entry and push SeenThread
   // If entry exists, reuse entry and push SeenThread for classloadAction
   PlaceholderEntry* find_and_add(int index, unsigned int hash,
-                                 Symbol* name, Handle loader,
+                                 Symbol* name, ClassLoaderData* loader_data,
                                  classloadAction action, Symbol* supername,
                                  Thread* thread);
 
   void remove_entry(int index, unsigned int hash,
-                    Symbol* name, Handle loader);
+                    Symbol* name, ClassLoaderData* loader_data);
 
 // Remove placeholder information
   void find_and_remove(int index, unsigned int hash,
-                       Symbol* name, Handle loader, Thread* thread);
+                       Symbol* name, ClassLoaderData* loader_data, Thread* thread);
 
   // GC support.
-  void oops_do(OopClosure* f);
+  void classes_do(KlassClosure* f);
 
   // JVMTI support
-  void entries_do(void f(Symbol*, oop));
+  void entries_do(void f(Symbol*));
 
 #ifndef PRODUCT
   void print();
@@ -157,11 +157,11 @@
 
 
  private:
-  oop               _loader;        // initiating loader
+  ClassLoaderData*  _loader_data;   // initiating loader
   bool              _havesupername; // distinguish between null supername, and unknown
   Symbol*           _supername;
   Thread*           _definer;       // owner of define token
-  klassOop          _instanceKlass; // instanceKlass from successful define
+  Klass*            _instanceKlass; // InstanceKlass from successful define
   SeenThread*       _superThreadQ;  // doubly-linked queue of Threads loading a superclass for this class
   SeenThread*       _loadInstanceThreadQ;  // loadInstance thread
                                     // can be multiple threads if classloader object lock broken by application
@@ -176,9 +176,8 @@
   // Simple accessors, used only by SystemDictionary
   Symbol*            klassname()           const { return literal(); }
 
-  oop                loader()              const { return _loader; }
-  void               set_loader(oop loader) { _loader = loader; }
-  oop*               loader_addr()         { return &_loader; }
+  ClassLoaderData*   loader_data()         const { return _loader_data; }
+  void               set_loader_data(ClassLoaderData* loader_data) { _loader_data = loader_data; }
 
   bool               havesupername()       const { return _havesupername; }
   void               set_havesupername(bool havesupername) { _havesupername = havesupername; }
@@ -192,9 +191,8 @@
   Thread*            definer()             const {return _definer; }
   void               set_definer(Thread* definer) { _definer = definer; }
 
-  klassOop           instanceKlass()     const {return _instanceKlass; }
-  void               set_instanceKlass(klassOop instanceKlass) { _instanceKlass = instanceKlass; }
-  klassOop*          instanceKlass_addr()   { return &_instanceKlass; }
+  Klass*             InstanceKlass()     const {return _instanceKlass; }
+  void               set_instanceKlass(Klass* InstanceKlass) { _instanceKlass = InstanceKlass; }
 
   SeenThread*        superThreadQ()        const { return _superThreadQ; }
   void               set_superThreadQ(SeenThread* SeenThread) { _superThreadQ = SeenThread; }
@@ -215,8 +213,8 @@
 
   // Test for equality
   // Entries are unique for class/classloader name pair
-  bool equals(Symbol* class_name, oop class_loader) const {
-    return (klassname() == class_name && loader() == class_loader);
+  bool equals(Symbol* class_name, ClassLoaderData* loader) const {
+    return (klassname() == class_name && loader_data() == loader);
   }
 
   SeenThread* actionToQueue(PlaceholderTable::classloadAction action) {
@@ -331,7 +329,7 @@
 
   // GC support
   // Applies "f->do_oop" to all root oops in the placeholder table.
-  void oops_do(OopClosure* blk);
+  void classes_do(KlassClosure* closure);
 
   // Print method doesn't append a cr
   void print() const  PRODUCT_RETURN;