private static bool Class_getPrimitiveClass(DynamicTypeWrapper.FinishContext context, CodeEmitter ilgen, MethodWrapper method, MethodAnalyzer ma, int opcodeIndex, MethodWrapper caller, ClassFile classFile, Instruction[] code, InstructionFlags[] flags)
{
ilgen.LazyEmitPop();
ilgen.Emit(OpCodes.Ldnull);
MethodWrapper mw = CoreClasses.java.lang.Class.Wrapper.GetMethodWrapper("<init>", "(Lcli.System.Type;)V", false);
mw.Link();
mw.EmitNewobj(ilgen);
return(true);
}
private static bool Class_desiredAssertionStatus(DynamicTypeWrapper.FinishContext context, CodeEmitter ilgen, MethodWrapper method, MethodAnalyzer ma, int opcodeIndex, MethodWrapper caller, ClassFile classFile, Instruction[] code, InstructionFlags[] flags)
{
TypeWrapper classLiteral = ilgen.PeekLazyClassLiteral();
if (classLiteral != null && classLiteral.GetClassLoader().RemoveAsserts)
{
ilgen.LazyEmitPop();
ilgen.LazyEmitLdc_I4(0);
return(true);
}
else
{
return(false);
}
}
private static bool Util_getInstanceTypeFromClass(DynamicTypeWrapper.FinishContext context, CodeEmitter ilgen, MethodWrapper method, MethodAnalyzer ma, int opcodeIndex, MethodWrapper caller, ClassFile classFile, Instruction[] code, InstructionFlags[] flags)
{
TypeWrapper tw = ilgen.PeekLazyClassLiteral();
if (tw != null)
{
ilgen.LazyEmitPop();
if (tw.IsRemapped && tw.IsFinal)
{
ilgen.Emit(OpCodes.Ldtoken, tw.TypeAsTBD);
}
else
{
ilgen.Emit(OpCodes.Ldtoken, tw.TypeAsBaseType);
}
ilgen.Emit(OpCodes.Call, Compiler.getTypeFromHandleMethod);
return(true);
}
return(false);
}
private static bool Reflection_getCallerClass(DynamicTypeWrapper.FinishContext context, CodeEmitter ilgen, MethodWrapper method, MethodAnalyzer ma, int opcodeIndex, MethodWrapper caller, ClassFile classFile, Instruction[] code, InstructionFlags[] flags)
{
if (caller.HasCallerID &&
opcodeIndex > 0 &&
(flags[opcodeIndex - 1] & InstructionFlags.BranchTarget) == 0 &&
code[opcodeIndex - 1].NormalizedOpCode == NormalizedByteCode.__iconst &&
code[opcodeIndex - 1].Arg1 == 2)
{
ilgen.LazyEmitPop();
int arg = caller.GetParametersForDefineMethod().Length - 1;
if (!caller.IsStatic)
{
arg++;
}
ilgen.Emit(OpCodes.Ldarg, (short)arg);
MethodWrapper mw = [email protected]("getCallerClass", "()Ljava.lang.Class;", false);
mw.Link();
mw.EmitCallvirt(ilgen);
return(true);
}
return(false);
}
internal override void Generate(CodeGenContext context, CodeEmitter ilgen)
{
ilgen.LazyEmitPop();
}
protected override void EmitSetImpl(CodeEmitter ilgen)
{
// when constant static final fields are updated, the JIT normally doesn't see that (because the
// constant value is inlined), so we emulate that behavior by emitting a Pop
ilgen.LazyEmitPop();
}
protected override void EmitSetImpl(CodeEmitter ilgen)
{
MethodInfo setter = property.GetSetMethod(true);
if (setter == null)
{
if(this.IsFinal)
{
ilgen.LazyEmitPop();
if(!this.IsStatic)
{
ilgen.LazyEmitPop();
}
}
else
{
DynamicPropertyFieldWrapper.EmitThrowNoSuchMethodErrorForSetter(ilgen, this.IsStatic);
}
}
else if(setter.IsStatic)
{
ilgen.Emit(OpCodes.Call, setter);
}
else
{
ilgen.Emit(OpCodes.Callvirt, setter);
}
}
protected override void EmitSetImpl(CodeEmitter ilgen)
{
if(setter == null)
{
if(this.IsFinal)
{
ilgen.LazyEmitPop();
if(!this.IsStatic)
{
ilgen.LazyEmitPop();
}
}
else
{
EmitThrowNoSuchMethodErrorForSetter(ilgen, this.IsStatic);
}
}
else if(setter.IsStatic)
{
setter.EmitCall(ilgen);
}
else
{
setter.EmitCallvirt(ilgen);
}
}
private static void DoEmit(DynamicTypeWrapper.FinishContext context, TypeWrapper wrapper, CodeEmitter ilgen, FieldWrapper field)
{
ConstructorBuilder cb;
bool exists;
lock (map)
{
exists = map.TryGetValue(field, out cb);
}
if (!exists)
{
// note that we don't need to lock here, because we're running as part of FinishCore, which is already protected by a lock
TypeWrapper arfuTypeWrapper = ClassLoaderWrapper.LoadClassCritical("ikvm.internal.IntrinsicAtomicReferenceFieldUpdater");
TypeBuilder tb = wrapper.TypeAsBuilder.DefineNestedType("__<ARFU>_" + field.Name + field.Signature.Replace('.', '/'), TypeAttributes.NestedPrivate | TypeAttributes.Sealed, arfuTypeWrapper.TypeAsBaseType);
EmitCompareAndSet("compareAndSet", tb, field.GetField());
EmitGet(tb, field.GetField());
EmitSet("set", tb, field.GetField());
cb = tb.DefineConstructor(MethodAttributes.Assembly, CallingConventions.Standard, Type.EmptyTypes);
lock (map)
{
map.Add(field, cb);
}
CodeEmitter ctorilgen = CodeEmitter.Create(cb);
ctorilgen.Emit(OpCodes.Ldarg_0);
MethodWrapper basector = arfuTypeWrapper.GetMethodWrapper("<init>", "()V", false);
basector.Link();
basector.EmitCall(ctorilgen);
ctorilgen.Emit(OpCodes.Ret);
context.RegisterPostFinishProc(delegate
{
arfuTypeWrapper.Finish();
tb.CreateType();
});
}
ilgen.LazyEmitPop();
ilgen.LazyEmitPop();
ilgen.LazyEmitPop();
ilgen.Emit(OpCodes.Newobj, cb);
}
