import static com.google.common.base.Verify.verify;
import static com.google.common.base.Verify.verifyNotNull;
import static java.util.Objects.requireNonNull;
-import static org.opendaylight.mdsal.binding.dom.codec.impl.ByteBuddyUtils.THIS;
+import static net.bytebuddy.implementation.bytecode.member.MethodVariableAccess.loadThis;
import static org.opendaylight.mdsal.binding.dom.codec.impl.ByteBuddyUtils.getField;
import static org.opendaylight.mdsal.binding.dom.codec.impl.ByteBuddyUtils.invokeMethod;
import static org.opendaylight.mdsal.binding.dom.codec.impl.ByteBuddyUtils.putField;
-import com.google.common.base.MoreObjects.ToStringHelper;
import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.Maps;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodHandles.Lookup;
+import java.lang.invoke.VarHandle;
import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Comparator;
-import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-import java.util.Objects;
import java.util.Optional;
-import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
import net.bytebuddy.ByteBuddy;
import net.bytebuddy.description.field.FieldDescription;
-import net.bytebuddy.description.method.MethodDescription;
import net.bytebuddy.description.type.TypeDefinition;
import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.description.type.TypeDescription.ForLoadedType;
import net.bytebuddy.description.type.TypeDescription.Generic;
import net.bytebuddy.dynamic.DynamicType.Builder;
import net.bytebuddy.dynamic.scaffold.InstrumentedType;
import net.bytebuddy.implementation.Implementation;
-import net.bytebuddy.implementation.Implementation.Context;
-import net.bytebuddy.implementation.bytecode.Addition;
import net.bytebuddy.implementation.bytecode.ByteCodeAppender;
-import net.bytebuddy.implementation.bytecode.Multiplication;
import net.bytebuddy.implementation.bytecode.StackManipulation;
import net.bytebuddy.implementation.bytecode.assign.TypeCasting;
import net.bytebuddy.implementation.bytecode.constant.ClassConstant;
-import net.bytebuddy.implementation.bytecode.constant.IntegerConstant;
import net.bytebuddy.implementation.bytecode.constant.TextConstant;
import net.bytebuddy.implementation.bytecode.member.MethodReturn;
import net.bytebuddy.implementation.bytecode.member.MethodVariableAccess;
-import net.bytebuddy.jar.asm.Label;
-import net.bytebuddy.jar.asm.MethodVisitor;
import net.bytebuddy.jar.asm.Opcodes;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.binding.dom.codec.impl.ClassGeneratorBridge.LocalNameProvider;
import org.opendaylight.mdsal.binding.dom.codec.loader.CodecClassLoader;
import org.opendaylight.mdsal.binding.dom.codec.loader.CodecClassLoader.ClassGenerator;
import org.opendaylight.mdsal.binding.dom.codec.loader.CodecClassLoader.GeneratorResult;
+import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* <p>
* Code generation here is probably more involved than usual mainly due to the fact we *really* want to express the
- * strong connection between a generated class and BindingCodecContext in terms of a true constant, which boils down to
- * {@code private static final NodeContextSupplier NCS}. Having such constants provides significant boost to JITs
- * ability to optimize code -- especially with inlining and constant propagation.
+ * strong connection between a generated class to the extent possible. In most cases (grouping-generated types) this
+ * involves one level of indirection, which is a safe approach. If we are dealing with a type generated outside of a
+ * grouping statement, though, we are guaranteed instantiation-invariance and hence can hard-wire to a runtime-constant
+ * {@link NodeContextSupplier} -- which provides significant boost to JITs ability to optimize code -- especially with
+ * inlining and constant propagation.
*
* <p>
* The accessor mapping performance is critical due to users typically not taking care of storing the results acquired
* we end up generating a class with the following layout:
* <pre>
* public final class Foo$$$codecImpl extends CodecDataObject implements Foo {
- * private static final AtomicRefereceFieldUpdater<Foo$$$codecImpl, Object> getBar$$$A;
+ * private static final VarHandle getBar$$$V;
* private volatile Object getBar;
*
- * public Foo$$$codecImpl(NormalizedNodeContainer data) {
+ * public Foo$$$codecImpl(DistinctNodeContainer data) {
* super(data);
* }
*
* public Bar getBar() {
- * return (Bar) codecMember(getBar$$$A, "bar");
+ * return (Bar) codecMember(getBar$$$V, "bar");
* }
* }
* </pre>
* This strategy minimizes the bytecode footprint and follows the generally good idea of keeping common logic in a
* single place in a maintainable form. The glue code is extremely light (~6 instructions), which is beneficial on both
* sides of invocation:
- * - generated method can readily be inlined into the caller
- * - it forms a call site into which codeMember() can be inlined with AtomicReferenceFieldUpdater being constant
+ * <ul>
+ * <li>generated method can readily be inlined into the caller</li>
+ * <li>it forms a call site into which codeMember() can be inlined with VarHandle being constant</li>
+ * </ul>
*
* <p>
- * The second point is important here, as it allows the invocation logic around AtomicRefereceFieldUpdater to completely
- * disappear, becoming synonymous with operations of a volatile field.
+ * The second point is important here, as it allows the invocation logic around VarHandle to completely disappear,
+ * becoming synonymous with operations on a field. Even though the field itself is declared as volatile, it is only ever
+ * accessed through helper method using VarHandles -- and those helpers are using relaxed field ordering
+ * of {@code getAcquire()}/{@code setRelease()} memory semantics.
*
* <p>
* Furthermore there are distinct {@code codecMember} methods, each of which supports a different invocation style:
* <p>
* The sticky point here is the NodeContextSupplier, as it is a heap object which cannot normally be looked up from the
* static context in which the static class initializer operates -- so we need perform some sort of a trick here.
- * Eventhough ByteBuddy provides facilities for bridging references to type fields, those facilities operate on volatile
- * fields -- hence they do not quite work for us.
+ * Even though ByteBuddy provides facilities for bridging references to type fields, those facilities operate on
+ * volatile fields -- hence they do not quite work for us.
*
* <p>
* Another alternative, which we used in Javassist-generated DataObjectSerializers, is to muck with the static field
- * using reflection -- which works, but requires redefinition of Field.modifiers, which is something Java 9 complains
+ * using reflection -- which works, but requires redefinition of Field.modifiers, which is something Java 9+ complains
* about quite noisily.
*
* <p>
* class loading operation. At this point the generator installs itself as the current generator for this thread via
* {@link ClassGeneratorBridge#setup(CodecDataObjectGenerator)} and allows the class to be loaded.
* <li>After the class has been loaded, but before the call returns, we will force the class to initialize, at which
- * point the static invocations will be redirect to {@link #resolveNodeContextSupplier(String)} and
+ * point the static invocations will be redirected to {@link #resolveNodeContextSupplier(String)} and
* {@link #resolveKey(String)} methods, thus initializing the fields to the intended constants.</li>
* <li>Before returning from the class loading call, the generator will detach itself via
* {@link ClassGeneratorBridge#tearDown(CodecDataObjectGenerator)}.</li>
*/
abstract class CodecDataObjectGenerator<T extends CodecDataObject<?>> implements ClassGenerator<T> {
// Not reusable definition: we can inline NodeContextSuppliers without a problem
+ // FIXME: MDSAL-443: wire this implementation, which requires that BindingRuntimeTypes provides information about
+ // types being generated from within a grouping
private static final class Fixed<T extends CodecDataObject<?>> extends CodecDataObjectGenerator<T>
implements NodeContextSupplierProvider<T> {
private final ImmutableMap<Method, NodeContextSupplier> properties;
- Fixed(final Builder<?> template, final ImmutableMap<Method, NodeContextSupplier> properties,
+ Fixed(final TypeDescription superClass, final ImmutableMap<Method, NodeContextSupplier> properties,
final @Nullable Method keyMethod) {
- super(template, keyMethod);
+ super(superClass, keyMethod);
this.properties = requireNonNull(properties);
}
return tmp;
}
- @Override
- ArrayList<Method> getterMethods() {
- return new ArrayList<>(properties.keySet());
- }
-
@Override
public NodeContextSupplier resolveNodeContextSupplier(final String methodName) {
final Optional<Entry<Method, NodeContextSupplier>> found = properties.entrySet().stream()
private final ImmutableMap<Method, ValueNodeCodecContext> simpleProperties;
private final Map<Method, Class<?>> daoProperties;
- Reusable(final Builder<?> template, final ImmutableMap<Method, ValueNodeCodecContext> simpleProperties,
+ Reusable(final TypeDescription superClass, final ImmutableMap<Method, ValueNodeCodecContext> simpleProperties,
final Map<Method, Class<?>> daoProperties, final @Nullable Method keyMethod) {
- super(template, keyMethod);
+ super(superClass, keyMethod);
this.simpleProperties = requireNonNull(simpleProperties);
this.daoProperties = requireNonNull(daoProperties);
}
return tmp;
}
- @Override
- ArrayList<Method> getterMethods() {
- final ArrayList<Method> ret = new ArrayList<>(simpleProperties.size() + daoProperties.size());
- ret.addAll(simpleProperties.keySet());
- ret.addAll(daoProperties.keySet());
- return ret;
- }
-
@Override
public String resolveLocalName(final String methodName) {
final Optional<Entry<Method, ValueNodeCodecContext>> found = simpleProperties.entrySet().stream()
private static final Logger LOG = LoggerFactory.getLogger(CodecDataObjectGenerator.class);
private static final Generic BB_BOOLEAN = TypeDefinition.Sort.describe(boolean.class);
- private static final Generic BB_DATAOBJECT = TypeDefinition.Sort.describe(DataObject.class);
- private static final Generic BB_HELPER = TypeDefinition.Sort.describe(ToStringHelper.class);
+ private static final Generic BB_OBJECT = TypeDefinition.Sort.describe(Object.class);
private static final Generic BB_INT = TypeDefinition.Sort.describe(int.class);
- private static final Comparator<Method> METHOD_BY_ALPHABET = Comparator.comparing(Method::getName);
-
- private static final StackManipulation ARRAYS_EQUALS = invokeMethod(Arrays.class, "equals",
- byte[].class, byte[].class);
- private static final StackManipulation OBJECTS_EQUALS = invokeMethod(Objects.class, "equals",
- Object.class, Object.class);
- private static final StackManipulation HELPER_ADD = invokeMethod(ToStringHelper.class, "add",
- String.class, Object.class);
+ private static final Generic BB_STRING = TypeDefinition.Sort.describe(String.class);
+ private static final TypeDescription BB_CDO = ForLoadedType.of(CodecDataObject.class);
+ private static final TypeDescription BB_ACDO = ForLoadedType.of(AugmentableCodecDataObject.class);
private static final StackManipulation FIRST_ARG_REF = MethodVariableAccess.REFERENCE.loadFrom(1);
private static final int PROT_FINAL = Opcodes.ACC_PROTECTED | Opcodes.ACC_FINAL | Opcodes.ACC_SYNTHETIC;
private static final int PUB_FINAL = Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL | Opcodes.ACC_SYNTHETIC;
- private static final Builder<?> CDO;
- private static final Builder<?> ACDO;
-
- static {
- final ByteBuddy bb = new ByteBuddy();
- CDO = bb.subclass(CodecDataObject.class).visit(ByteBuddyUtils.computeFrames());
- ACDO = bb.subclass(AugmentableCodecDataObject.class).visit(ByteBuddyUtils.computeFrames());
- }
+ private static final ByteBuddy BB = new ByteBuddy();
- private final Builder<?> template;
+ private final TypeDescription superClass;
private final Method keyMethod;
- CodecDataObjectGenerator(final Builder<?> template, final @Nullable Method keyMethod) {
- this.template = requireNonNull(template);
+ CodecDataObjectGenerator(final TypeDescription superClass, final @Nullable Method keyMethod) {
+ this.superClass = requireNonNull(superClass);
this.keyMethod = keyMethod;
}
final Class<D> bindingInterface, final ImmutableMap<Method, ValueNodeCodecContext> simpleProperties,
final Map<Method, Class<?>> daoProperties, final Method keyMethod) {
return loader.generateClass(bindingInterface, "codecImpl",
- new Reusable<>(CDO, simpleProperties, daoProperties, keyMethod));
+ new Reusable<>(BB_CDO, simpleProperties, daoProperties, keyMethod));
}
static <D extends DataObject, T extends CodecDataObject<T>> Class<T> generateAugmentable(
final ImmutableMap<Method, ValueNodeCodecContext> simpleProperties,
final Map<Method, Class<?>> daoProperties, final Method keyMethod) {
return loader.generateClass(bindingInterface, "codecImpl",
- new Reusable<>(ACDO, simpleProperties, daoProperties, keyMethod));
+ new Reusable<>(BB_ACDO, simpleProperties, daoProperties, keyMethod));
}
@Override
final Class<?> bindingInterface) {
LOG.trace("Generating class {}", fqcn);
+ final Generic bindingDef = TypeDefinition.Sort.describe(bindingInterface);
@SuppressWarnings("unchecked")
- Builder<T> builder = (Builder<T>) template.name(fqcn).implement(bindingInterface);
+ Builder<T> builder = (Builder<T>) BB.subclass(Generic.Builder.parameterizedType(superClass, bindingDef).build())
+ .name(fqcn).implement(bindingDef);
builder = generateGetters(builder);
new KeyMethodImplementation(methodName, retType));
}
- // Index all property methods, turning them into "getFoo()" invocations, retaining order. We will be using
- // those invocations in each of the three methods. Note that we do not glue the invocations to 'this', as we
- // will be invoking them on 'other' in codecEquals()
- final ArrayList<Method> properties = getterMethods();
- // Make sure properties are alpha-sorted
- properties.sort(METHOD_BY_ALPHABET);
- final ImmutableMap<StackManipulation, Method> methods = Maps.uniqueIndex(properties,
- ByteBuddyUtils::invokeMethod);
-
// Final bits:
return GeneratorResult.of(builder
// codecHashCode() ...
.defineMethod("codecHashCode", BB_INT, PROT_FINAL)
- .intercept(new Implementation.Simple(new CodecHashCode(methods)))
- // ... codecEquals() ...
- .defineMethod("codecEquals", BB_BOOLEAN, PROT_FINAL).withParameter(BB_DATAOBJECT)
- .intercept(codecEquals(methods))
- // ... and codecFillToString() ...
- .defineMethod("codecFillToString", BB_HELPER, PROT_FINAL).withParameter(BB_HELPER)
- .intercept(codecFillToString(methods))
+ .intercept(codecHashCode(bindingInterface))
+ // ... equals(Object) ...
+ .defineMethod("codecEquals", BB_BOOLEAN, PROT_FINAL).withParameter(BB_OBJECT)
+ .intercept(codecEquals(bindingInterface))
+ // ... toString() ...
+ .defineMethod("toString", BB_STRING, PUB_FINAL)
+ .intercept(toString(bindingInterface))
// ... and build it
.make());
}
abstract Builder<T> generateGetters(Builder<T> builder);
- abstract ArrayList<Method> getterMethods();
-
- private static Implementation codecEquals(final ImmutableMap<StackManipulation, Method> properties) {
- // Label for 'return false;'
- final Label falseLabel = new Label();
- // Condition for 'if (!...)'
- final StackManipulation ifFalse = ByteBuddyUtils.ifEq(falseLabel);
-
- final List<StackManipulation> manipulations = new ArrayList<>(properties.size() * 6 + 5);
- for (Entry<StackManipulation, Method> entry : properties.entrySet()) {
- // if (!java.util.(Objects|Arrays).equals(getFoo(), other.getFoo())) {
- // return false;
- // }
- manipulations.add(THIS);
- manipulations.add(entry.getKey());
- manipulations.add(FIRST_ARG_REF);
- manipulations.add(entry.getKey());
- manipulations.add(entry.getValue().getReturnType().isArray() ? ARRAYS_EQUALS : OBJECTS_EQUALS);
- manipulations.add(ifFalse);
- }
-
- // return true;
- manipulations.add(IntegerConstant.ONE);
- manipulations.add(MethodReturn.INTEGER);
- // L0: return false;
- manipulations.add(ByteBuddyUtils.markLabel(falseLabel));
- manipulations.add(IntegerConstant.ZERO);
- manipulations.add(MethodReturn.INTEGER);
-
- return new Implementation.Simple(manipulations.toArray(new StackManipulation[0]));
+ private static Implementation codecHashCode(final Class<?> bindingInterface) {
+ return new Implementation.Simple(
+ // return Foo.bindingHashCode(this);
+ loadThis(),
+ invokeMethod(bindingInterface, BindingMapping.BINDING_HASHCODE_NAME, bindingInterface),
+ MethodReturn.INTEGER);
}
- private static Implementation codecFillToString(final ImmutableMap<StackManipulation, Method> properties) {
- final List<StackManipulation> manipulations = new ArrayList<>(properties.size() * 4 + 2);
- // push 'return helper' to stack...
- manipulations.add(FIRST_ARG_REF);
- for (Entry<StackManipulation, Method> entry : properties.entrySet()) {
- // .add("getFoo", getFoo())
- manipulations.add(new TextConstant(entry.getValue().getName()));
- manipulations.add(THIS);
- manipulations.add(entry.getKey());
- manipulations.add(HELPER_ADD);
- }
- // ... execute 'return helper'
- manipulations.add(MethodReturn.REFERENCE);
+ private static Implementation codecEquals(final Class<?> bindingInterface) {
+ return new Implementation.Simple(
+ // return Foo.bindingEquals(this, obj);
+ loadThis(),
+ FIRST_ARG_REF,
+ invokeMethod(bindingInterface, BindingMapping.BINDING_EQUALS_NAME, bindingInterface, Object.class),
+ MethodReturn.INTEGER);
+ }
- return new Implementation.Simple(manipulations.toArray(new StackManipulation[0]));
+ private static Implementation toString(final Class<?> bindingInterface) {
+ return new Implementation.Simple(
+ // return Foo.bindingToString(this);
+ loadThis(),
+ invokeMethod(bindingInterface, BindingMapping.BINDING_TO_STRING_NAME, bindingInterface),
+ MethodReturn.REFERENCE);
}
private abstract static class AbstractMethodImplementation implements Implementation {
- private static final Generic BB_ARFU = TypeDefinition.Sort.describe(AtomicReferenceFieldUpdater.class);
+ private static final Generic BB_HANDLE = TypeDefinition.Sort.describe(VarHandle.class);
private static final Generic BB_OBJECT = TypeDefinition.Sort.describe(Object.class);
private static final StackManipulation OBJECT_CLASS = ClassConstant.of(TypeDescription.OBJECT);
- private static final StackManipulation ARFU_NEWUPDATER = invokeMethod(AtomicReferenceFieldUpdater.class,
- "newUpdater", Class.class, Class.class, String.class);
+ private static final StackManipulation LOOKUP = invokeMethod(MethodHandles.class, "lookup");
+ private static final StackManipulation FIND_VAR_HANDLE = invokeMethod(Lookup.class,
+ "findVarHandle", Class.class, String.class, Class.class);
static final int PRIV_CONST = Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC | Opcodes.ACC_FINAL
| Opcodes.ACC_SYNTHETIC;
final TypeDescription retType;
// getFoo
final String methodName;
- // getFoo$$$A
- final String arfuName;
+ // getFoo$$$V
+ final String handleName;
AbstractMethodImplementation(final String methodName, final TypeDescription retType) {
this.methodName = requireNonNull(methodName);
this.retType = requireNonNull(retType);
- this.arfuName = methodName + "$$$A";
+ this.handleName = methodName + "$$$V";
}
@Override
public InstrumentedType prepare(final InstrumentedType instrumentedType) {
final InstrumentedType tmp = instrumentedType
- // private static final AtomicReferenceFieldUpdater<This, Object> getFoo$$$A;
- .withField(new FieldDescription.Token(arfuName, PRIV_CONST, BB_ARFU))
+ // private static final VarHandle getFoo$$$V;
+ .withField(new FieldDescription.Token(handleName, PRIV_CONST, BB_HANDLE))
// private volatile Object getFoo;
.withField(new FieldDescription.Token(methodName, PRIV_VOLATILE, BB_OBJECT));
return tmp.withInitializer(new ByteCodeAppender.Simple(
- // getFoo$$$A = AtomicReferenceFieldUpdater.newUpdater(This.class, Object.class, "getFoo");
+ // TODO: acquiring lookup is expensive, we should share it across all initialization
+ // getFoo$$$V = MethodHandles.lookup().findVarHandle(This.class, "getFoo", Object.class);
+ LOOKUP,
ClassConstant.of(tmp),
- OBJECT_CLASS,
new TextConstant(methodName),
- ARFU_NEWUPDATER,
- putField(tmp, arfuName)));
+ OBJECT_CLASS,
+ FIND_VAR_HANDLE,
+ putField(tmp, handleName)));
}
}
private static final class KeyMethodImplementation extends AbstractMethodImplementation {
private static final StackManipulation CODEC_KEY = invokeMethod(CodecDataObject.class,
- "codecKey", AtomicReferenceFieldUpdater.class);
+ "codecKey", VarHandle.class);
KeyMethodImplementation(final String methodName, final TypeDescription retType) {
super(methodName, retType);
@Override
public ByteCodeAppender appender(final Target implementationTarget) {
- final TypeDescription instrumentedType = implementationTarget.getInstrumentedType();
return new ByteCodeAppender.Simple(
- // return (FooType) codecKey(getFoo$$$A);
- THIS,
- getField(instrumentedType, arfuName),
+ // return (FooType) codecKey(getFoo$$$V);
+ loadThis(),
+ getField(implementationTarget.getInstrumentedType(), handleName),
CODEC_KEY,
TypeCasting.to(retType),
MethodReturn.REFERENCE);
*/
private static final class SimpleGetterMethodImplementation extends AbstractMethodImplementation {
private static final StackManipulation CODEC_MEMBER = invokeMethod(CodecDataObject.class,
- "codecMember", AtomicReferenceFieldUpdater.class, String.class);
+ "codecMember", VarHandle.class, String.class);
private static final StackManipulation BRIDGE_RESOLVE = invokeMethod(ClassGeneratorBridge.class,
"resolveLocalName", String.class);
private static final Generic BB_STRING = TypeDefinition.Sort.describe(String.class);
public ByteCodeAppender appender(final Target implementationTarget) {
final TypeDescription instrumentedType = implementationTarget.getInstrumentedType();
return new ByteCodeAppender.Simple(
- // return (FooType) codecMember(getFoo$$$A, getFoo$$$S);
- THIS,
- getField(instrumentedType, arfuName),
+ // return (FooType) codecMember(getFoo$$$V, getFoo$$$S);
+ loadThis(),
+ getField(instrumentedType, handleName),
getField(instrumentedType, stringName),
CODEC_MEMBER,
TypeCasting.to(retType),
private static final class StructuredGetterMethodImplementation extends AbstractMethodImplementation {
private static final StackManipulation CODEC_MEMBER = invokeMethod(CodecDataObject.class,
- "codecMember", AtomicReferenceFieldUpdater.class, Class.class);
+ "codecMember", VarHandle.class, Class.class);
private final Class<?> bindingClass;
@Override
public ByteCodeAppender appender(final Target implementationTarget) {
- final TypeDescription instrumentedType = implementationTarget.getInstrumentedType();
return new ByteCodeAppender.Simple(
- // return (FooType) codecMember(getFoo$$$A, FooType.class);
- THIS,
- getField(instrumentedType, arfuName),
+ // return (FooType) codecMember(getFoo$$$V, FooType.class);
+ loadThis(),
+ getField(implementationTarget.getInstrumentedType(), handleName),
ClassConstant.of(TypeDefinition.Sort.describe(bindingClass).asErasure()),
CODEC_MEMBER,
TypeCasting.to(retType),
private static final class SupplierGetterMethodImplementation extends AbstractMethodImplementation {
private static final StackManipulation CODEC_MEMBER = invokeMethod(CodecDataObject.class,
- "codecMember", AtomicReferenceFieldUpdater.class, NodeContextSupplier.class);
+ "codecMember", VarHandle.class, NodeContextSupplier.class);
private static final StackManipulation BRIDGE_RESOLVE = invokeMethod(ClassGeneratorBridge.class,
"resolveNodeContextSupplier", String.class);
private static final Generic BB_NCS = TypeDefinition.Sort.describe(NodeContextSupplier.class);
public ByteCodeAppender appender(final Target implementationTarget) {
final TypeDescription instrumentedType = implementationTarget.getInstrumentedType();
return new ByteCodeAppender.Simple(
- // return (FooType) codecMember(getFoo$$$A, getFoo$$$C);
- THIS,
- getField(instrumentedType, arfuName),
+ // return (FooType) codecMember(getFoo$$$V, getFoo$$$C);
+ loadThis(),
+ getField(instrumentedType, handleName),
getField(instrumentedType, contextName),
CODEC_MEMBER,
TypeCasting.to(retType),
MethodReturn.REFERENCE);
}
}
-
- private static final class CodecHashCode implements ByteCodeAppender {
- private static final StackManipulation THIRTY_ONE = IntegerConstant.forValue(31);
- private static final StackManipulation LOAD_RESULT = MethodVariableAccess.INTEGER.loadFrom(1);
- private static final StackManipulation STORE_RESULT = MethodVariableAccess.INTEGER.storeAt(1);
- private static final StackManipulation ARRAYS_HASHCODE = invokeMethod(Arrays.class, "hashCode", byte[].class);
- private static final StackManipulation OBJECTS_HASHCODE = invokeMethod(Objects.class, "hashCode", Object.class);
-
- private final ImmutableMap<StackManipulation, Method> properties;
-
- CodecHashCode(final ImmutableMap<StackManipulation, Method> properties) {
- this.properties = requireNonNull(properties);
- }
-
- @Override
- public Size apply(final MethodVisitor methodVisitor, final Context implementationContext,
- final MethodDescription instrumentedMethod) {
- final List<StackManipulation> manipulations = new ArrayList<>(properties.size() * 8 + 4);
- // int result = 1;
- manipulations.add(IntegerConstant.ONE);
- manipulations.add(STORE_RESULT);
-
- for (Entry<StackManipulation, Method> entry : properties.entrySet()) {
- // result = 31 * result + java.util.(Objects,Arrays).hashCode(getFoo());
- manipulations.add(THIRTY_ONE);
- manipulations.add(LOAD_RESULT);
- manipulations.add(Multiplication.INTEGER);
- manipulations.add(THIS);
- manipulations.add(entry.getKey());
- manipulations.add(entry.getValue().getReturnType().isArray() ? ARRAYS_HASHCODE : OBJECTS_HASHCODE);
- manipulations.add(Addition.INTEGER);
- manipulations.add(STORE_RESULT);
- }
- // return result;
- manipulations.add(LOAD_RESULT);
- manipulations.add(MethodReturn.INTEGER);
-
- StackManipulation.Size operandStackSize = new StackManipulation.Compound(manipulations)
- .apply(methodVisitor, implementationContext);
- return new Size(operandStackSize.getMaximalSize(), instrumentedMethod.getStackSize() + 1);
- }
- }
}
Code Review / mdsal.git / blobdiff