The utility classes made life simpler prior to Java 8, but their usage
was reduced to in-place initialization of collections, for which the
pattern of new CollectionType <> (Arrays.asList (...)) can be endured.

The users of the utility classes were updated to cope without them.

src-disl-agent/Makefile: use 'ld' instead of 'gcc' for linking.
src-disl-agent/Makefile: avoid -flto for normal builds, may be broken on old compilers found in Ubuntu.
src-disl-agent/Makefile: support building 32-bit and 64-bit versions of the agent library.
build.xml: adjusted to look for the library in os-arch-specific directory.

suite/sendspecial: add dummy events before sending objects with data to force buffer flush in the agent.
suite/shadowstring: remove test as it is now subsumed by the sendspecial test.

REDispatch: improve the class documentation -- it's a public API class after all.

NetReferenceHelper: add getUniqueId() method that will return a net reference with the special payload bit masked.
ShadowObject: add (package private) getUniqueId() method.
ShadowObject: add (package private) isSpecial() method.
ShadowObject, ShadowClass: move (package private) getClassId() method from ShadowClass to ShadowObject.
ShadowObject: remove the getNetRef() method to (sort of) keep a lid on the raw net reference.
ShadowObject: test equality using getUniqueId() instead of raw net reference, so that objects with the same it but one containing special payload are considered equal.
ShadowObjectTable: only call updateFrom() on an existing object when the other object is "special", i.e., it contains special payload.
ShadowClassTable: avoid using net reference directly, use isSpecial() and getClassId() on the shadow object.

  so for now, we just have a special ShadowClass variant to avoid crashes.
  Getting complete class information will probably require using reflection
  at the agent side, but let's postpone it until it is really needed.
- Add a battery of simple tests to check basic sanity of LambdaShadowClass.
- Add a simple ShadowVM test to check that we can pass a lambda object to REDispatch.
- Rework class name generation in ShadowClass and PrimitiveShadowClass to
  avoid calling overridable public methods.

ShadowClassTable: use ASM Type as a key to per-class-cloader class bytecode map instead of converting from internal class name to class name.

NewClassHandler: only call a single method on ShadowClassTable to handle the request.
ShadowClassTable: rename load() to loadClass()
ShadowClassTable: simplify implementation of loadClass() by factoring out low-level bits.

ObjectShadowClassTest: enable tests for reflection-like behavior of isInstance() and isAssignableFrom() on self.

ShadowClass: add extendsType() to allow checking if a shadow class represents a type that extends a particular type.
ShadowObjectTable: replace usage of isAssignableFromThread() with equalsType() and extendsType() in __createShadowObject().
ShadowObjectTable: eliminate isAssignableFromThread().

ShadowObjectTable: eliminate duplicated tracing from __createShadowObject() by moving it into the upper-level lambda.
ShadowObjectTable: compare to String.class.getName() instead of a string literal in __createShadowObject().

ShadowObject: refactor equals() to perform type-specific checks in __equals().
ShadowObject: reuse net reference equality check in the updateFrom() method.

ShadowClass: eliminate temporaries in the check for equality of class loaders.
ShadowClass: calculate hashCode() from class and class loader identifier.
ShadowClass: rename getShadowClassLoader() to getClassLoader() and make it package private until the API stabilizes.

ShadowClassTestBase: remove @Theory annotation from the getModifiersMatchesReflection() method.

  much common code to ShadowClass. Also avoid duplication information that
  can be easily extracted from ASM Type or ClassNode.
- Add test that test the basic functionality of the three concrete
  subclasses of ShadowClass.
- Modify build.xml to pick up the new tests.

ClassNodeHelper: moved to ch.usi.dag.util.asm to make it accessible to the Shadow VM implementation.
DiSL, DislClasses, ReflectionTest: updated imports to reflect the class movement.

  (currently unimplemented) instead of an array of string descriptors.
- Add getInterfaceDescriptors() to return an array of string descriptors
  for consistency with the normal reflection API.
- Renamed getDeclaredClasses() to getDeclaredClassDescriptors().
- Changed getDeclaredClasses() to return an array of type descriptors
  instead of an array of internal names of the declared classes.

abstract ShadowClass to derive answers to most queries, leaving the subclasses
to only deal with to deal with the specifics. 

ArrayShadowClass: reorder constructor parameters to consistently pass ASM Type after net reference.
ObjectShadowClass: make the class final.
PrimitiveShadowClass: make the class package private and final.
ShadowClassTable: reflect the changes in constructor parameter order.

ShadowClassTable: other cosmetic changes to simplify future merges.

ShadowString, ShadowThread: get rid of overriden hashCode() and equals() and rely on the superclass implementation that only cares about net reference equality.
ShadowObject, ShadowString, ShadowThread: make a shadow object updatable from other object with the same net reference (required for partially-constructed special objects).
ShadowString, ShadowThread: get rid of setter methods in favor of updateFrom() method.
ShadowThread: make additional information about a thread atomically updateable.
ShadowClassTable: log when the JAVA_LANG_CLASS reference is updated.
ShadowClassTable, ShadowObjectTable: make the classes final.
ShadowObjectTable: use the updateFrom() method from shadow object instead of hand-coding updates in the registration method.
ShadowObjectTable: simplify the get() method by extracting code to create shadow objects in conjunction with the use of computeIfAbsent() method on the shadow object map.

ShadowClassTable: preprocess data from ClassInfoLoader before calling newInstance().
ShadowClassTable: simplify the implementation of newInstance(), extract class creation into __createShadowClass().
ShadowObject: make getNetRef() package private.
ShadowObject: use get() on the JAVA_LANG_CLASS atomic reference.
ObjectShadowClass: use ASM Type instead of String with class signature.

NetReferenceHelper: make the method names conform to normal Java style.
ShadowClass, ShadowObject, ShadowClassTable, ShadowObjectTable: updated to reflect the changes.

ShadowString, ShadowThread: add constructors for un-initialized shadows.
StringInfoHandler, ThreadInfoHandler: let ShadowObjectTable handle the registration, keep only IO in the handler code.
ShadowObjectTable: drop the debug parameter from the register() method, use logging instead.
ShadowObjectTable: use special constructors when creating un-initialized shadows of special objects.
ShadowClassTable: avoid using the debug parameter when calling the register() static method.

MethodInfo: do all copying on demand.
MethodInfo: add getDescriptor() to provide full method type information.

FieldInfo: getType() renamed to getDescriptor(), as it really returns a String descriptor of the type.
MethodInfo: get*Type() or get*Types() renamed to get*Descriptor() or get*Descriptors() for the same reason as in case of FieldInfo.
ArrayShadowClass, ObjectShadowClass: updated to reflect the changes.

ShadowCommonClass: renamed to ObjectShadowClass
ShadowPrimitiveClass: renamed to PrimitiveShadowClass
ShadowClassTable: updated to reflect the changes