/**
* Generate customized bytecode for a given LambdaForm.
*/
public static MemberName generateCustomizedCode(LambdaForm form, MethodType invokerType)
{
try
{
MemberName memberName = new MemberName();
memberName._clazz(AnonymousClass.Instance);
memberName._name(form.debugName);
memberName._type(invokerType);
memberName._flags(MethodHandleNatives.Constants.MN_IS_METHOD | MethodHandleNatives.Constants.ACC_STATIC | (MethodHandleNatives.Constants.REF_invokeStatic << MethodHandleNatives.Constants.MN_REFERENCE_KIND_SHIFT));
memberName.vmtarget = new NativeInvokerBytecodeGenerator(form, invokerType).generateCustomizedCodeBytes();
return(memberName);
}
#if DEBUG
catch (BailoutException x)
{
Console.WriteLine(x.Message);
Console.WriteLine("generateCustomizedCode: " + form + ", " + invokerType);
}
#else
catch (BailoutException)
{
}
#endif
return(InvokerBytecodeGenerator.generateCustomizedCode(form, invokerType));
}
internal virtual LambdaForm CollectArgumentsForm(int pos, MethodType collectorType)
{
int collectorArity = collectorType.ParameterCount();
bool dropResult = (collectorType.ReturnType() == typeof(void));
if (collectorArity == 1 && !dropResult)
{
return(FilterArgumentForm(pos, basicType(collectorType.ParameterType(0))));
}
BasicType[] newTypes = BasicType.basicTypes(collectorType.ParameterList());
Transform.Kind kind = (dropResult ? Transform.Kind.COLLECT_ARGS_TO_VOID : Transform.Kind.COLLECT_ARGS);
if (dropResult && collectorArity == 0) // pure side effect
{
pos = 1;
}
Transform key = Transform.Of(kind, pos, collectorArity, BasicType.basicTypesOrd(newTypes));
LambdaForm form = GetInCache(key);
if (form != null)
{
assert(form.Arity_Renamed == LambdaForm.Arity_Renamed - (dropResult ? 0 : 1) + collectorArity);
return(form);
}
form = MakeArgumentCombinationForm(pos, collectorType, false, dropResult);
return(PutInCache(key, form));
}
private static void MaybeCompile(LambdaForm lform, MemberName m)
{
if (VerifyAccess.isSamePackage(m.DeclaringClass, typeof(MethodHandle)))
{
// Help along bootstrapping...
lform.CompileToBytecode();
}
}
/// <summary>
/// Create a LF which simply reinvokes a target of the given basic type. </summary>
internal static LambdaForm MakeReinvokerForm(MethodHandle target, int whichCache, Object constraint, String debugString, bool forceInline, NamedFunction getTargetFn, NamedFunction preActionFn)
{
MethodType mtype = target.Type().BasicType();
bool customized = (whichCache <0 || mtype.ParameterSlotCount()> MethodType.MAX_MH_INVOKER_ARITY);
bool hasPreAction = (preActionFn != null);
LambdaForm form;
if (!customized)
{
form = mtype.Form().CachedLambdaForm(whichCache);
if (form != null)
{
return(form);
}
}
const int THIS_DMH = 0;
const int ARG_BASE = 1;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int ARG_LIMIT = ARG_BASE + mtype.parameterCount();
int ARG_LIMIT = ARG_BASE + mtype.ParameterCount();
int nameCursor = ARG_LIMIT;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int PRE_ACTION = hasPreAction ? nameCursor++ : -1;
int PRE_ACTION = hasPreAction ? nameCursor++: -1;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int NEXT_MH = customized ? -1 : nameCursor++;
int NEXT_MH = customized ? -1 : nameCursor++;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int REINVOKE = nameCursor++;
int REINVOKE = nameCursor++;
LambdaForm.Name[] names = LambdaForm.Arguments(nameCursor - ARG_LIMIT, mtype.InvokerType());
assert(names.Length == nameCursor);
names[THIS_DMH] = names[THIS_DMH].WithConstraint(constraint);
Object[] targetArgs;
if (hasPreAction)
{
names[PRE_ACTION] = new LambdaForm.Name(preActionFn, names[THIS_DMH]);
}
if (customized)
{
targetArgs = Arrays.CopyOfRange(names, ARG_BASE, ARG_LIMIT, typeof(Object[]));
names[REINVOKE] = new LambdaForm.Name(target, targetArgs); // the invoker is the target itself
}
else
{
names[NEXT_MH] = new LambdaForm.Name(getTargetFn, names[THIS_DMH]);
targetArgs = Arrays.CopyOfRange(names, THIS_DMH, ARG_LIMIT, typeof(Object[]));
targetArgs[0] = names[NEXT_MH]; // overwrite this MH with next MH
names[REINVOKE] = new LambdaForm.Name(mtype, targetArgs);
}
form = new LambdaForm(debugString, ARG_LIMIT, names, forceInline);
if (!customized)
{
form = mtype.Form().SetCachedLambdaForm(whichCache, form);
}
return(form);
}
internal virtual BoundMethodHandle BindArgumentD(BoundMethodHandle mh, int pos, double value)
{
assert(mh.SpeciesData() == OldSpeciesData());
BasicType bt = D_TYPE;
MethodType type2 = BindArgumentType(mh, pos, bt);
LambdaForm form2 = BindArgumentForm(1 + pos);
return(mh.CopyWithExtendD(type2, form2, value));
}
// Factory method.
internal static LambdaFormEditor LambdaFormEditor(LambdaForm lambdaForm)
{
// TO DO: Consider placing intern logic here, to cut down on duplication.
// lambdaForm = findPreexistingEquivalent(lambdaForm)
// Always use uncustomized version for editing.
// It helps caching and customized LambdaForms reuse transformCache field to keep a link to uncustomized version.
return(new LambdaFormEditor(lambdaForm.Uncustomize()));
}
internal virtual LambdaForm SpreadArgumentsForm(int pos, Class arrayType, int arrayLength)
{
Class elementType = arrayType.ComponentType;
Class erasedArrayType = arrayType;
if (!elementType.Primitive)
{
erasedArrayType = typeof(Object[]);
}
BasicType bt = basicType(elementType);
int elementTypeKey = bt.ordinal();
if (bt.basicTypeClass() != elementType)
{
if (elementType.Primitive)
{
elementTypeKey = TYPE_LIMIT + Wrapper.forPrimitiveType(elementType).ordinal();
}
}
Transform key = Transform.Of(Transform.Kind.SPREAD_ARGS, pos, elementTypeKey, arrayLength);
LambdaForm form = GetInCache(key);
if (form != null)
{
assert(form.Arity_Renamed == LambdaForm.Arity_Renamed - arrayLength + 1);
return(form);
}
LambdaFormBuffer buf = Buffer();
buf.StartEdit();
assert(pos <= MethodType.MAX_JVM_ARITY);
assert(pos + arrayLength <= LambdaForm.Arity_Renamed);
assert(pos > 0); // cannot spread the MH arg itself
Name spreadParam = new Name(L_TYPE);
Name checkSpread = new Name(MethodHandleImpl.Lazy.NF_checkSpreadArgument, spreadParam, arrayLength);
// insert the new expressions
int exprPos = LambdaForm.Arity();
buf.InsertExpression(exprPos++, checkSpread);
// adjust the arguments
MethodHandle aload = MethodHandles.ArrayElementGetter(erasedArrayType);
for (int i = 0; i < arrayLength; i++)
{
Name loadArgument = new Name(aload, spreadParam, i);
buf.InsertExpression(exprPos + i, loadArgument);
buf.ReplaceParameterByCopy(pos + i, exprPos + i);
}
buf.InsertParameter(pos, spreadParam);
form = buf.EndEdit();
return(PutInCache(key, form));
}
private NativeInvokerBytecodeGenerator(LambdaForm lambdaForm, MethodType invokerType)
{
if (invokerType != invokerType.basicType())
{
throw new BailoutException(Bailout.NotBasicType, invokerType);
}
this.lambdaForm = lambdaForm;
this.invokerType = invokerType;
this.delegateType = MethodHandleUtil.GetMemberWrapperDelegateType(invokerType);
MethodInfo mi = MethodHandleUtil.GetDelegateInvokeMethod(delegateType);
Type[] paramTypes = MethodHandleUtil.GetParameterTypes(typeof(object[]), mi);
// HACK the code we generate is not verifiable (known issue: locals aren't typed correctly), so we stick the DynamicMethod into mscorlib (a security critical assembly)
this.dm = new DynamicMethod(lambdaForm.debugName, mi.ReturnType, paramTypes, typeof(object).Module, true);
this.ilgen = CodeEmitter.Create(this.dm);
if (invokerType.parameterCount() > MethodHandleUtil.MaxArity)
{
this.packedArgType = paramTypes[paramTypes.Length - 1];
this.packedArgPos = paramTypes.Length - 1;
}
else
{
this.packedArgPos = Int32.MaxValue;
}
locals = new CodeEmitterLocal[lambdaForm.names.Length];
for (int i = lambdaForm._arity(); i < lambdaForm.names.Length; i++)
{
Name name = lambdaForm.names[i];
if (name.index() != i)
{
throw new BailoutException(Bailout.PreconditionViolated, "name.index() != i");
}
switch (name.typeChar())
{
case 'L':
locals[i] = ilgen.DeclareLocal(Types.Object);
break;
case 'I':
locals[i] = ilgen.DeclareLocal(Types.Int32);
break;
case 'J':
locals[i] = ilgen.DeclareLocal(Types.Int64);
break;
case 'F':
locals[i] = ilgen.DeclareLocal(Types.Single);
break;
case 'D':
locals[i] = ilgen.DeclareLocal(Types.Double);
break;
case 'V':
break;
default:
throw new BailoutException(Bailout.PreconditionViolated, "Unsupported typeChar(): " + name.typeChar());
}
}
}
private static LambdaForm PreparedLambdaForm(MethodType mtype, int which)
{
LambdaForm lform = mtype.Form().CachedLambdaForm(which);
if (lform != null)
{
return(lform);
}
lform = MakePreparedLambdaForm(mtype, which);
return(mtype.Form().SetCachedLambdaForm(which, lform));
}
internal override BoundMethodHandle CopyWithExtendF(MethodType mt, LambdaForm lf, float narg)
/*non-public*/
{
try
{
return((BoundMethodHandle)SPECIES_DATA.ExtendWith(F_TYPE).Constructor().invokeBasic(mt, lf, narg));
}
catch (Throwable ex)
{
throw uncaughtException(ex);
}
}
private static LambdaForm PreparedFieldLambdaForm(sbyte formOp, bool isVolatile, Class ftype)
{
int afIndex = AfIndex(formOp, isVolatile, FtypeKind(ftype));
LambdaForm lform = ACCESSOR_FORMS[afIndex];
if (lform != null)
{
return(lform);
}
lform = MakePreparedFieldLambdaForm(formOp, isVolatile, FtypeKind(ftype));
ACCESSOR_FORMS[afIndex] = lform; // don't bother with a CAS
return(lform);
}
private static DirectMethodHandle MakeAllocator(MemberName ctor)
{
assert(ctor.Constructor && ctor.Name.Equals("<init>"));
Class instanceClass = ctor.DeclaringClass;
ctor = ctor.AsConstructor();
assert(ctor.Constructor && ctor.ReferenceKind == REF_newInvokeSpecial) : ctor;
MethodType mtype = ctor.MethodType.ChangeReturnType(instanceClass);
LambdaForm lform = PreparedLambdaForm(ctor);
MemberName init = ctor.AsSpecial();
assert(init.MethodType.ReturnType() == typeof(void));
return(new Constructor(mtype, lform, ctor, init, instanceClass));
}
internal virtual LambdaForm FoldArgumentsForm(int foldPos, bool dropResult, MethodType combinerType)
{
int combinerArity = combinerType.ParameterCount();
Transform.Kind kind = (dropResult ? Transform.Kind.FOLD_ARGS_TO_VOID : Transform.Kind.FOLD_ARGS);
Transform key = Transform.Of(kind, foldPos, combinerArity);
LambdaForm form = GetInCache(key);
if (form != null)
{
assert(form.Arity_Renamed == LambdaForm.Arity_Renamed - (kind == Transform.Kind.FOLD_ARGS ? 1 : 0));
return(form);
}
form = MakeArgumentCombinationForm(foldPos, combinerType, true, dropResult);
return(PutInCache(key, form));
}
internal LambdaFormBuffer(LambdaForm lf)
{
this.Arity = lf.Arity_Renamed;
Names = lf.Names;
int result = lf.Result;
if (result == LAST_RESULT)
{
result = Length - 1;
}
if (result >= 0 && lf.Names[result].Type_Renamed != V_TYPE)
{
ResultName = lf.Names[result];
}
DebugName = lf.DebugName;
assert(lf.NameRefsAreLegal());
}
/// <summary>
/// Create a LF which can invoke the given method.
/// Cache and share this structure among all methods with
/// the same basicType and refKind.
/// </summary>
private static LambdaForm PreparedLambdaForm(MemberName m)
{
assert(m.Invocable) : m; // call preparedFieldLambdaForm instead
MethodType mtype = m.InvocationType.BasicType();
assert(!m.MethodHandleInvoke || "invokeBasic".Equals(m.Name)) : m;
int which;
switch (m.ReferenceKind)
{
case REF_invokeVirtual:
which = LF_INVVIRTUAL;
break;
case REF_invokeStatic:
which = LF_INVSTATIC;
break;
case REF_invokeSpecial:
which = LF_INVSPECIAL;
break;
case REF_invokeInterface:
which = LF_INVINTERFACE;
break;
case REF_newInvokeSpecial:
which = LF_NEWINVSPECIAL;
break;
default:
throw new InternalError(m.ToString());
}
if (which == LF_INVSTATIC && ShouldBeInitialized(m))
{
// precompute the barrier-free version:
PreparedLambdaForm(mtype, which);
which = LF_INVSTATIC_INIT;
}
LambdaForm lform = PreparedLambdaForm(mtype, which);
MaybeCompile(lform, m);
assert(lform.MethodType().DropParameterTypes(0, 1).Equals(m.InvocationType.BasicType())) : Arrays.asList(m, m.InvocationType.BasicType(), lform, lform.MethodType());
return(lform);
}
internal virtual LambdaForm FilterArgumentForm(int pos, BasicType newType)
{
Transform key = Transform.Of(Transform.Kind.FILTER_ARG, pos, newType.ordinal());
LambdaForm form = GetInCache(key);
if (form != null)
{
assert(form.Arity_Renamed == LambdaForm.Arity_Renamed);
assert(form.ParameterType(pos) == newType);
return(form);
}
BasicType oldType = LambdaForm.ParameterType(pos);
MethodType filterType = MethodType.MethodType(oldType.basicTypeClass(), newType.basicTypeClass());
form = MakeArgumentCombinationForm(pos, filterType, false, false);
return(PutInCache(key, form));
}
// hooked up via map.xml (as a replacement for makePairwiseConvertByEditor)
public static MethodHandle makePairwiseConvert(MethodHandle target, MethodType srcType, bool strict, bool monobox)
{
#if FIRST_PASS
return(null);
#else
object[] convSpecs = MethodHandleImpl.computeValueConversions(srcType, target.type(), strict, monobox);
List <LambdaForm.Name> names = new List <LambdaForm.Name>();
names.Add(new LambdaForm.Name(0, LambdaForm.BasicType.L_TYPE));
for (int i = 0; i < srcType.parameterCount(); i++)
{
names.Add(new LambdaForm.Name(i + 1, LambdaForm.BasicType.basicType(srcType.parameterType(i))));
}
LambdaForm.Name[] invokeArgs = new LambdaForm.Name[srcType.parameterCount()];
for (int i = 0; i < invokeArgs.Length; i++)
{
object convSpec = convSpecs[i];
if (convSpec == null)
{
invokeArgs[i] = names[i + 1];
}
else
{
LambdaForm.Name temp = new LambdaForm.Name(convSpec as MethodHandle ?? MethodHandleImpl.Lazy.MH_castReference.bindTo(convSpec), names[i + 1]);
names.Add(temp);
invokeArgs[i] = temp;
}
}
names.Add(new LambdaForm.Name(target, invokeArgs));
if (convSpecs[convSpecs.Length - 1] != null)
{
object convSpec = convSpecs[convSpecs.Length - 1];
if (convSpec != java.lang.Void.TYPE)
{
names.Add(new LambdaForm.Name(convSpec as MethodHandle ?? MethodHandleImpl.Lazy.MH_castReference.bindTo(convSpec), names[names.Count - 1]));
}
}
if (target.type().returnType() == java.lang.Void.TYPE && srcType.returnType() != java.lang.Void.TYPE)
{
names.Add(new LambdaForm.Name(LambdaForm.constantZero(LambdaForm.BasicType.basicType(srcType.returnType()))));
}
LambdaForm form = new LambdaForm("PairwiseConvert", srcType.parameterCount() + 1, names.ToArray());
return(new LightWeightMethodHandle(srcType, form));
#endif
}
// Factory methods:
internal static DirectMethodHandle Make(sbyte refKind, Class receiver, MemberName member)
{
MethodType mtype = member.MethodOrFieldType;
if (!member.Static)
{
if (!receiver.IsSubclassOf(member.DeclaringClass) || member.Constructor)
{
throw new InternalError(member.ToString());
}
mtype = mtype.InsertParameterTypes(0, receiver);
}
if (!member.Field)
{
if (refKind == REF_invokeSpecial)
{
member = member.AsSpecial();
LambdaForm lform = PreparedLambdaForm(member);
return(new Special(mtype, lform, member));
}
else
{
LambdaForm lform = PreparedLambdaForm(member);
return(new DirectMethodHandle(mtype, lform, member));
}
}
else
{
LambdaForm lform = PreparedFieldLambdaForm(member);
if (member.Static)
{
long offset = MethodHandleNatives.staticFieldOffset(member);
Object @base = MethodHandleNatives.staticFieldBase(member);
return(new StaticAccessor(mtype, lform, member, @base, offset));
}
else
{
long offset = MethodHandleNatives.objectFieldOffset(member);
assert(offset == (int)offset);
return(new Accessor(mtype, lform, member, (int)offset));
}
}
}
internal virtual LambdaForm AddArgumentForm(int pos, BasicType type)
{
Transform key = Transform.Of(Transform.Kind.ADD_ARG, pos, type.ordinal());
LambdaForm form = GetInCache(key);
if (form != null)
{
assert(form.Arity_Renamed == LambdaForm.Arity_Renamed + 1);
assert(form.ParameterType(pos) == type);
return(form);
}
LambdaFormBuffer buf = Buffer();
buf.StartEdit();
buf.InsertParameter(pos, new Name(type));
form = buf.EndEdit();
return(PutInCache(key, form));
}
/// Editing methods for lambda forms.
// Each editing method can (potentially) cache the edited LF so that it can be reused later.
internal virtual LambdaForm BindArgumentForm(int pos)
{
Transform key = Transform.Of(Transform.Kind.BIND_ARG, pos);
LambdaForm form = GetInCache(key);
if (form != null)
{
assert(form.ParameterConstraint(0) == NewSpeciesData(LambdaForm.ParameterType(pos)));
return(form);
}
LambdaFormBuffer buf = Buffer();
buf.StartEdit();
BoundMethodHandle.SpeciesData oldData = OldSpeciesData();
BoundMethodHandle.SpeciesData newData = NewSpeciesData(LambdaForm.ParameterType(pos));
Name oldBaseAddress = LambdaForm.Parameter(0);// BMH holding the values
Name newBaseAddress;
NamedFunction getter = newData.GetterFunction(oldData.FieldCount());
if (pos != 0)
{
// The newly created LF will run with a different BMH.
// Switch over any pre-existing BMH field references to the new BMH class.
buf.ReplaceFunctions(oldData.GetterFunctions(), newData.GetterFunctions(), oldBaseAddress);
newBaseAddress = oldBaseAddress.withConstraint(newData);
buf.RenameParameter(0, newBaseAddress);
buf.ReplaceParameterByNewExpression(pos, new Name(getter, newBaseAddress));
}
else
{
// cannot bind the MH arg itself, unless oldData is empty
assert(oldData == BoundMethodHandle.SpeciesData.EMPTY);
newBaseAddress = (new Name(L_TYPE)).withConstraint(newData);
buf.ReplaceParameterByNewExpression(0, new Name(getter, newBaseAddress));
buf.InsertParameter(0, newBaseAddress);
}
form = buf.EndEdit();
return(PutInCache(key, form));
}
// Constructors and factory methods in this class *must* be package scoped or private.
private DirectMethodHandle(MethodType mtype, LambdaForm form, MemberName member) : base(mtype, form)
{
if (!member.Resolved)
{
throw new InternalError();
}
if (member.DeclaringClass.Interface && member.Method && !member.Abstract)
{
// Check for corner case: invokeinterface of Object method
MemberName m = new MemberName(typeof(Object), member.Name, member.MethodType, member.ReferenceKind);
m = MemberName.Factory.ResolveOrNull(m.ReferenceKind, m, null);
if (m != null && m.Public)
{
assert(member.ReferenceKind == m.ReferenceKind); // else this.form is wrong
member = m;
}
}
this.Member = member;
}
internal virtual LambdaForm DupArgumentForm(int srcPos, int dstPos)
{
Transform key = Transform.Of(Transform.Kind.DUP_ARG, srcPos, dstPos);
LambdaForm form = GetInCache(key);
if (form != null)
{
assert(form.Arity_Renamed == LambdaForm.Arity_Renamed - 1);
return(form);
}
LambdaFormBuffer buf = Buffer();
buf.StartEdit();
assert(LambdaForm.Parameter(srcPos).Constraint == null);
assert(LambdaForm.Parameter(dstPos).Constraint == null);
buf.ReplaceParameterByCopy(dstPos, srcPos);
form = buf.EndEdit();
return(PutInCache(key, form));
}
/// <summary>
/// Create a LF which can access the given field.
/// Cache and share this structure among all fields with
/// the same basicType and refKind.
/// </summary>
private static LambdaForm PreparedFieldLambdaForm(MemberName m)
{
Class ftype = m.FieldType;
bool isVolatile = m.Volatile;
sbyte formOp;
switch (m.ReferenceKind)
{
case REF_getField:
formOp = AF_GETFIELD;
break;
case REF_putField:
formOp = AF_PUTFIELD;
break;
case REF_getStatic:
formOp = AF_GETSTATIC;
break;
case REF_putStatic:
formOp = AF_PUTSTATIC;
break;
default:
throw new InternalError(m.ToString());
}
if (ShouldBeInitialized(m))
{
// precompute the barrier-free version:
PreparedFieldLambdaForm(formOp, isVolatile, ftype);
assert((AF_GETSTATIC_INIT - AF_GETSTATIC) == (AF_PUTSTATIC_INIT - AF_PUTSTATIC));
formOp += (sbyte)(AF_GETSTATIC_INIT - AF_GETSTATIC);
}
LambdaForm lform = PreparedFieldLambdaForm(formOp, isVolatile, ftype);
MaybeCompile(lform, m);
assert(lform.MethodType().DropParameterTypes(0, 1).Equals(m.InvocationType.BasicType())) : Arrays.asList(m, m.InvocationType.BasicType(), lform, lform.MethodType());
return(lform);
}
/**
* Generate customized bytecode for a given LambdaForm.
*/
public static MemberName generateCustomizedCode(LambdaForm form, MethodType invokerType)
{
try
{
MemberName memberName = new MemberName();
memberName._clazz(AnonymousClass.Instance);
memberName._name(form.debugName);
memberName._type(invokerType);
memberName._flags(MethodHandleNatives.Constants.MN_IS_METHOD | MethodHandleNatives.Constants.ACC_STATIC | (MethodHandleNatives.Constants.REF_invokeStatic << MethodHandleNatives.Constants.MN_REFERENCE_KIND_SHIFT));
memberName.vmtarget = new NativeInvokerBytecodeGenerator(form, invokerType).generateCustomizedCodeBytes();
return memberName;
}
#if DEBUG
catch (BailoutException x)
{
Console.WriteLine(x.Message);
Console.WriteLine("generateCustomizedCode: " + form + ", " + invokerType);
}
#else
catch (BailoutException)
{
}
#endif
return InvokerBytecodeGenerator.generateCustomizedCode(form, invokerType);
}
internal override MethodHandle CopyWith(MethodType mt, LambdaForm lf)
{
return(new StaticAccessor(mt, lf, Member, StaticBase, StaticOffset));
}
internal StaticAccessor(MethodType mtype, LambdaForm form, MemberName member, Object staticBase, long staticOffset) : base(mtype, form, member)
{
this.FieldType = member.FieldType;
this.StaticBase = staticBase;
this.StaticOffset = staticOffset;
}
internal override MethodHandle CopyWith(MethodType mt, LambdaForm lf)
{
return(new Accessor(mt, lf, Member, FieldOffset));
}
internal Accessor(MethodType mtype, LambdaForm form, MemberName member, int fieldOffset) : base(mtype, form, member)
{
this.FieldType = member.FieldType;
this.FieldOffset = fieldOffset;
}
internal override MethodHandle CopyWith(MethodType mt, LambdaForm lf)
{
return(new Constructor(mt, lf, Member, InitMethod, InstanceClass));
}
internal Constructor(MethodType mtype, LambdaForm form, MemberName constructor, MemberName initMethod, Class instanceClass) : base(mtype, form, constructor)
{
this.InitMethod = initMethod;
this.InstanceClass = instanceClass;
assert(initMethod.Resolved);
}
internal override MethodHandle CopyWith(MethodType mt, LambdaForm lf)
{
return(new Special(mt, lf, Member));
}
internal Special(MethodType mtype, LambdaForm form, MemberName member) : base(mtype, form, member)
{
}
public static MemberName generateCustomizedCode(LambdaForm form, MethodType invokerType)
{
return null;
}
