Allows creating an asm.Attribute and directly providing the content
as a byte array.

Cherry-pick of
lrytz/scala@9a7e518

Fail early when adding an instruction that already belongs to a
different instruction list.

Cherry-pick of
lrytz/scala@eccd0dc

Cherry-pick of
lrytz/scala@2458576

Cherry-pick of
lrytz/scala@34e3220

Make class MethodWriter public and add accessors for maxLocals and
maxStack. This is the simplest way to compute the maxs using the
ASM framework. It is used in the optimizer, see
scala/scala@90781e8

Cherry-pick of
lrytz/scala@91810c9

Fix typos. This change was initially part of
scala/scala@549dc88

Cherry-pick of
lrytz/scala@e1fbc7f

Cherry-pick of 97075ea

Adds a method `setStack` to analysis.Frame which allows setting the
dataflow value of a stack slot.

Used in nullness analysis. After, for example, an instance call,
aliases of the receiver can be set to NotNull, both in locals and
on the stack.

Introduces a number of methods that are called when initializing or
updating abstract values in an analyzer frame.

Before this commit, Analyzer.analyze and Frame.execute would always
call Interpreter.newValue for initializing or updating frame values.

Having multiple methods allows users to return more precise values
for the individual cases. For example, in a nullness analysis, the
initial value for the `this` parameter of an instance method can be
set to not-null.

…ll copied values

Before this change, `Frame.execute` did not invoke the interpreter's
`copyInstruction` method for all values that are pushed on the frame's
when executing some copying instructions.

For example, in the case of SWAP, copyInstruction is invoked:

    value2 = pop();
    value1 = pop();
    push(interpreter.copyOperation(insn, value2));
    push(interpreter.copyOperation(insn, value1));

For DUP on the other hand, the original value is pushed onto the
stack without notifying the interpreter:

    value1 = pop();
    push(value1);
    push(interpreter.copyOperation(insn, value1));

This leads to a problem for the `SourceInterpreter`, which collects
for every value a set of potential producer instructions. Given the
bytecode sequence

    NEW java/lang/Object
    DUP
    INVOKESPECIAL java/lang/Object.<init> ()V

In the frame of the INVOKESPECIAL instruction, the value on the stack
lists as its producer the `NEW` operation instead of the `DUP`, which
not expected.

The method `findItemByIndex` only looked at the first item in each
bucket of the `items` hash table.

Also, in case the item was not found, the counter `i` would be at
`items.length`, therefore the access `items[i]` crashed with an
ArrayIndexOutOfBoundsException.

Fixes the issue scala/scala-asm#8.