From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- libjava/gnu/classpath/jdwp/VMIdManager.java | 435 ++++++++++++++++++++++++++++ 1 file changed, 435 insertions(+) create mode 100644 libjava/gnu/classpath/jdwp/VMIdManager.java (limited to 'libjava/gnu/classpath/jdwp/VMIdManager.java') diff --git a/libjava/gnu/classpath/jdwp/VMIdManager.java b/libjava/gnu/classpath/jdwp/VMIdManager.java new file mode 100644 index 000000000..f787a8cdc --- /dev/null +++ b/libjava/gnu/classpath/jdwp/VMIdManager.java @@ -0,0 +1,435 @@ +/* VMIdManager.java -- A reference/example implementation of a manager for + JDWP object/reference type IDs + + Copyright (C) 2005, 2006, 2007 Free Software Foundation + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + + +package gnu.classpath.jdwp; + +import gnu.classpath.jdwp.exception.InvalidClassException; +import gnu.classpath.jdwp.exception.InvalidObjectException; +import gnu.classpath.jdwp.id.*; + +import java.lang.ref.Reference; +import java.lang.ref.ReferenceQueue; +import java.lang.ref.SoftReference; +import java.nio.ByteBuffer; +import java.util.HashMap; +import java.util.Hashtable; + +/** + * This class manages objects and referencetypes that are reported + * to the debugger. All objects and referencetypes reported to the + * debugger should go through this manager. + * + * A brief summary of what an IdManager must provide: + * + * + * public ObjectId getObjectId (Object theObject); + * public ObjectId get (long id); + * public ObjectId readObjectId (ByteBuffer bb); + * public ReferenceTypeId getReferenceTypeId (Class clazz); + * public ReferenceTypeId getReferenceType (long id); + * public ReferenceTypeId readReferenceTypeId (ByteBuffer bb); + * + * + * See the javadoc on these methods later in this file for more + * information on these functions. + * + * NOTE: All IDs handled by the ID manager (all object and reference + * type IDs) are assumed to be of type long. + * + * NOTE: This class does not manage virtual machine-specific types, + * like methods, fields, and frames. These already have unique IDs within + * the virtual machine and do not need further abstraction here. + * + * @author Keith Seitz (keiths@redhat.com) + */ +public class VMIdManager +{ + // This factory generates ids for objects and types that may + // be sent to a debugger. + private static class IdFactory + { + // ID of last object / referencetype + private static Object _idLock = new Object (); + private static Object _ridLock = new Object (); + private static long _lastId = 0; + private static long _lastRid = 0; + + // A list of all ID types + private static HashMap _idList = new HashMap (); + + // Initialize the id list with known types + static + { + // ObjectId and ArrayId are special cases. See newObjectId. + _idList.put (ClassLoaderId.typeClass, ClassLoaderId.class); + _idList.put (ClassObjectId.typeClass, ClassObjectId.class); + _idList.put (StringId.typeClass, StringId.class); + _idList.put (ThreadId.typeClass, ThreadId.class); + _idList.put (ThreadGroupId.typeClass, ThreadGroupId.class); + } + + /** + * Returns a new id for the given object + * + * @param obj SoftReference of the object for which an id is desired + * @returns a suitable object id + */ + public static ObjectId newObjectId (SoftReference obj) + { + ObjectId id = null; + Object object = obj.get (); + + // Special case: arrays + if (object.getClass ().isArray ()) + id = new ArrayId (); + else + { + // Loop through all classes until we hit baseclass + Class myClass; + for (myClass = object.getClass (); myClass != null; + myClass = myClass.getSuperclass ()) + { + Class clz = (Class) _idList.get (myClass); + if (clz != null) + { + try + { + id = (ObjectId) clz.newInstance (); + synchronized (_idLock) + { + id.setId (++_lastId); + } + id.setReference (obj); + return id; + } + catch (InstantiationException ie) + { + // This really should not happen + throw new RuntimeException ("cannot create new ID", ie); + } + catch (IllegalAccessException iae) + { + // This really should not happen + throw new RuntimeException ("illegal access of ID", iae); + } + } + } + + /* getSuperclass returned null and no matching ID type found. + So it must derive from Object. */ + id = new ObjectId (); + } + + synchronized (_idLock) + { + id.setId (++_lastId); + } + id.setReference (obj); + return id; + } + + /** + * Returns a new reference type id for the given class + * + * @param ref SoftReference to the desired type + * @returns a suitable reference type id or null when the + * reference is cleared. + */ + public static ReferenceTypeId newReferenceTypeId (SoftReference ref) + { + ReferenceTypeId id; + Class clazz = (Class) ref.get (); + if (clazz == null) + return null; + + if (clazz.isArray ()) + id = new ArrayReferenceTypeId (); + else if (clazz.isInterface ()) + id = new InterfaceReferenceTypeId (); + else + id = new ClassReferenceTypeId (); + id.setReference (ref); + synchronized (_ridLock) + { + id.setId (++_lastRid); + } + return id; + } + } + + /** + * This class is a SoftReferenceIdentity type that is used by + * the ID manager. + */ + class ReferenceKey extends SoftReference + { + // Hash code of referent + private int _hash; + + /** + * Constructs a new ReferenceKey object + * with the given referent. + * + *

This constructor should only be used for object lookups + * by the backend. + * + * @param referent the object to reference + */ + public ReferenceKey (Object referent) + { + super (referent); + _hash = referent.hashCode (); + } + + /** + * Constructs a new ReferenceKey object + * with the given referent and reference queue. + * + *

The JDWP back-end stores a ReferenceKey + * with its corresponding JdwpId. This constructor + * is used by the back-end when adding new IDs to be managed. + * + * @param referent the object to reference + * @param queue the queue to which to report garbage collections + */ + public ReferenceKey (Object referent, ReferenceQueue queue) + { + super (referent, queue); + _hash = referent.hashCode (); + } + + /** + * Returns the hash code of the referent. + * This seems hacky, but is required in order to use this class + * as a hash table key. + * + * @returns the hash code of the referent + */ + public int hashCode () + { + return _hash; + } + + /** + * Comparator for keys + * + * This method can be used in two ways: + * + *

    + *
  1. For table lookups, where we want to compare referents
    2. + *
  2. For clearing GCd objects, where we want to compare the actual + * key object (not the referent)
    3. + *
+ */ + public boolean equals (Object obj) + { + if (obj instanceof ReferenceKey) + { + ReferenceKey ref = (ReferenceKey) obj; + + /* First check if the two references are the same. + If they are, that means we must be clearing GCd objects. */ + if (this == obj) + return true; + + return (ref.get () == get ()); + } + + return false; + } + } + + // instance of VMIdManager + private static VMIdManager _idm = new VMIdManager (); + + // A reference queue for our objects + private ReferenceQueue _refQueue; + + // Mapping of objects (ReferenceKey) to IDs (ObjectId) + private Hashtable _oidTable; + + // Mapping of ID numbers (Long) to IDs (ObjectId) + private Hashtable _idTable; + + /* Mapping of class (ReferenceKey) to IDs (ReferenceTypeId) for reference + types. Unlike other types, reference id types are NEVER released. */ + private Hashtable _classTable; + + // Mapping of ID numbers (Long) to reference type IDs (ReferenceTypeId) + private Hashtable _ridTable; + + /** + * Gets the instance of VMIdManager, constructing a new one + * if none currently exists. + */ + public static VMIdManager getDefault () + { + return _idm; + } + + // Constructs a new IdManager + private VMIdManager () + { + _refQueue = new ReferenceQueue (); + _oidTable = new Hashtable (50); + _idTable = new Hashtable (50); + _classTable = new Hashtable (20); + _ridTable = new Hashtable (20); + } + + // Updates the object ID table, removing IDs whose objects have + // been garbage collected. + private void _update () + { + Reference ref; + while ((ref = _refQueue.poll ()) != null) + { + ObjectId id = (ObjectId) _oidTable.get (ref); + _oidTable.remove (ref); + _idTable.remove (new Long (id.getId ())); + } + } + + /** + * Returns an id for the given object, adding it + * if it does not have an id. + * + * @param theObject the object to get an ID/add + * @returns the ID of the object + */ + public ObjectId getObjectId (Object theObject) + { + // Special case: null object. + if (theObject == null) + return new NullObjectId (); + + ReferenceKey ref = new ReferenceKey (theObject, _refQueue); + ObjectId id = (ObjectId) _oidTable.get (ref); + if (id == null) + { + // update the tables -- this is an arbitrary place to put this + _update (); + + // Object not found. Make new id for it + id = IdFactory.newObjectId (ref); + _oidTable.put (ref, id); + _idTable.put (new Long (id.getId ()), id); + } + + return id; + } + + /** + * Returns the JdwpId for a given ID. Unlike + * getId, it throws an exception if the ID is not + * known. + * + * @param id the numerical ID of the desired JdwpId + * @throws InvalidObjectException if the ID is not found + */ + public ObjectId get (long id) + throws InvalidObjectException + { + // Special case: null object id. + if (id == 0) + return new NullObjectId (); + + ObjectId oid = (ObjectId) _idTable.get (new Long (id)); + if (oid == null) + throw new InvalidObjectException (id); + + return oid; + } + + public ObjectId readObjectId (ByteBuffer bb) + throws InvalidObjectException + { + long id = bb.getLong (); + return get (id); + } + + /** + * Gets the reference type id for the given class, creating + * a new one if it does not already have an id + * + * @param clazz the class for which to get an ID + * @returns the ID of the class + */ + public ReferenceTypeId getReferenceTypeId (Class clazz) + { + ReferenceKey ref = new ReferenceKey (clazz); + ReferenceTypeId id = (ReferenceTypeId)_classTable.get (ref); + if (id == null) + { + // Object not found. Make new id for it + id = IdFactory.newReferenceTypeId (ref); + _classTable.put (ref, id); + _ridTable.put (new Long (id.getId ()), id); + } + + return id; + } + + /** + * Returns the ReferenceTypeId for a given ID. Unlike + * getReferenceTypeId, it throws an exception if the ID is not + * known. + * + * @param id the numerical ID of the desired reference type + * @throws InvalidClassException if the ID is not found + */ + public ReferenceTypeId getReferenceType (long id) + throws InvalidClassException + { + ReferenceTypeId rid = (ReferenceTypeId) _ridTable.get (new Long (id)); + if (rid == null) + throw new InvalidClassException (id); + + return rid; + } + + public ReferenceTypeId readReferenceTypeId (ByteBuffer bb) + throws InvalidClassException + { + long id = bb.getLong (); + return getReferenceType (id); + } +} -- cgit v1.2.3