the resolver, do it where the static context is being used, i.e., in the
GuardHelper and SCGenerator.

SCGenerator, StaticContextMethod: move invocation of the static context
method into the StaticContextMethod class to make the class pull its weight
a bit.

AbstractParser, SnippetParser: source code cleanups related to annotation
processing.

method name, and method descriptor.

This causes problems when the same class is loaded multiple times by
different class loaders. The basic block static context will use CFG
that was made for a different method and will not find instruction
nodes of the new method, leading to all sorts of errors.

Instead, memoize the last CFG along with the corresponding method
node, and if the method node changes, recreate the CFG. This seems
to be enough to avoid regenerating the CFG for the same method.

To some degree, this is the result of poor static context interface
and reuse of a single static context instance for multiple shadows.
This needs to be redesigned some time in future.

When using the compiler (clang) to link object files, passing the
-shared flag is OK, but when talking directly to the linker, the
-dylib flag needs to be used instead.

dislreagent.c: remove extraneous arguments from call to buffs_utility_get()

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.