| public EmitLoadDefault ( TypeSymbol type, TypeRefMask typemask ) : void | ||
| type | TypeSymbol | |
| typemask | TypeRefMask | |
| 리턴 | void | |
internal override void Emit(CodeGenerator cg)
{
cg.EmitSequencePoint(this.PhpSyntax);
var rtype = cg.Routine.ReturnType;
var rvoid = rtype.SpecialType == SpecialType.System_Void;
//
if (this.Returned == null)
{
if (rvoid)
{
// <void>
}
else
{
// <default>
cg.EmitLoadDefault(rtype, cg.Routine.ResultTypeMask);
}
}
else
{
if (rvoid)
{
// <expr>;
cg.EmitPop(this.Returned.Emit(cg));
}
else
{
// return (T)<expr>;
cg.EmitConvert(this.Returned, rtype);
}
}
// .ret
cg.EmitRet(rtype);
}
/// <summary>
/// Emits the given conversion. 'from' and 'to' matches the classified conversion.
/// </summary>
public static void EmitConversion(this CodeGenerator cg, CommonConversion conversion, TypeSymbol from, TypeSymbol to, TypeSymbol op = null, bool @checked = false)
{
// {from}, {op} is loaded on stack
//
if (conversion.Exists == false)
{
throw cg.NotImplementedException($"Conversion from '{from}' to '{to}' ");
}
if (conversion.IsNullable)
{
if (from.IsNullableType(out var ttype))
{
if (op != null)
{
// TODO
throw new ArgumentException(nameof(op));
}
var lbltrue = new NamedLabel("has value");
var lblend = new NamedLabel("end");
var tmp = cg.GetTemporaryLocal(from, true);
cg.Builder.EmitLocalStore(tmp);
// Template: tmp.HasValue ? convert(tmp.Value) : default
cg.Builder.EmitLocalAddress(tmp);
cg.EmitCall(ILOpCode.Call, cg.DeclaringCompilation.System_Nullable_T_HasValue(from));
cg.Builder.EmitBranch(ILOpCode.Brtrue, lbltrue);
// default:
cg.EmitLoadDefault(to);
cg.Builder.EmitBranch(ILOpCode.Br, lblend);
// cg.Builder.AdjustStack(-1); // ?
// lbltrue:
cg.Builder.MarkLabel(lbltrue);
// Template: convert( tmp.GetValueOrDefault() )
cg.Builder.EmitLocalAddress(tmp);
cg.EmitCall(ILOpCode.Call, cg.DeclaringCompilation.System_Nullable_T_GetValueOrDefault(from)).Expect(ttype);
EmitConversion(cg, conversion.WithIsNullable(false), ttype, to, op, @checked);
// lblend:
cg.Builder.MarkLabel(lblend);
return;
}
if (to.IsNullableType(out ttype)) // NOTE: not used yet
{
// new Nullable<TType>( convert(from) )
EmitConversion(cg, conversion.WithIsNullable(false), from, ttype, op, @checked);
cg.EmitCall(ILOpCode.Newobj, ((NamedTypeSymbol)to).InstanceConstructors[0]); // new Nullable<T>( STACK )
return;
}
throw Roslyn.Utilities.ExceptionUtilities.Unreachable;
}
if (conversion.IsIdentity)
{
if (op != null)
{
throw new ArgumentException(nameof(op));
}
if (to.SpecialType == SpecialType.System_Void)
{
// POP
cg.EmitPop(from);
}
// nop
}
else if (conversion.IsNumeric)
{
if (op != null)
{
throw new ArgumentException(nameof(op));
}
EmitNumericConversion(cg, from, to, @checked: @checked);
}
else if (conversion.IsReference)
{
if (op != null)
{
throw new ArgumentException(nameof(op));
}
// TODO: ensure from/to is a valid reference type
cg.EmitCastClass(to);
}
else if (conversion.IsUserDefined)
{
var method = (MethodSymbol)conversion.MethodSymbol;
var ps = method.Parameters;
int pconsumed = 0;
if (method.HasThis)
{
if (from.IsValueType)
{
if (op != null || from.IsVoid())
{
throw new ArgumentException(nameof(op));
}
cg.EmitStructAddr(from);
}
}
else
{
if (ps[0].RefKind != RefKind.None)
{
throw new InvalidOperationException();
}
if (from != ps[0].Type)
{
if (op != null)
{
if (!ps[0].Type.IsAssignableFrom(from))
{
throw new ArgumentException(nameof(op));
}
}
else
{
EmitImplicitConversion(cg, from, ps[0].Type, @checked: @checked);
}
}
pconsumed++;
}
if (op != null)
{
if (ps.Length > pconsumed)
{
EmitImplicitConversion(cg, op, ps[pconsumed].Type, @checked: @checked);
}
pconsumed++;
}
// Context ctx,
if (ps.Length > pconsumed && SpecialParameterSymbol.IsContextParameter(ps[pconsumed]))
{
cg.EmitLoadContext();
pconsumed++;
}
if (ps.Length != pconsumed)
{
throw new InvalidOperationException();
}
EmitImplicitConversion(cg, cg.EmitCall(method.IsVirtual ? ILOpCode.Callvirt : ILOpCode.Call, method), to, @checked: true);
}
else
{
throw new NotImplementedException();
}
}
void EmitInit(Emit.PEModuleBuilder module, DiagnosticBag diagnostic, PhpCompilation compilation, SynthesizedStaticLocHolder holder, BoundExpression initializer)
{
var loctype = holder.ValueField.Type;
bool requiresContext = initializer != null && initializer.RequiresContext;
if (requiresContext)
{
// emit Init only if it needs Context
holder.EmitInit(module, (il) =>
{
var cg = new CodeGenerator(il, module, diagnostic, OptimizationLevel.Release, false,
holder.ContainingType, new ArgPlace(compilation.CoreTypes.Context, 1), new ArgPlace(holder, 0));
var valuePlace = new FieldPlace(cg.ThisPlaceOpt, holder.ValueField);
// Template: this.value = <initilizer>;
valuePlace.EmitStorePrepare(il);
cg.EmitConvert(initializer, valuePlace.TypeOpt);
valuePlace.EmitStore(il);
//
il.EmitRet(true);
});
}
// default .ctor
holder.EmitCtor(module, (il) =>
{
if (!requiresContext)
{
// emit default value only if it won't be initialized by Init above
var cg = new CodeGenerator(il, module, diagnostic, OptimizationLevel.Release, false,
holder.ContainingType, null, new ArgPlace(holder, 0));
var valuePlace = new FieldPlace(cg.ThisPlaceOpt, holder.ValueField);
// Template: this.value = default(T);
valuePlace.EmitStorePrepare(il);
if (initializer != null)
{
cg.EmitConvert(initializer, valuePlace.TypeOpt);
}
else
{
cg.EmitLoadDefault(valuePlace.TypeOpt, 0);
}
valuePlace.EmitStore(il);
}
//
il.EmitRet(true);
});
}
