public override MethodIL EmitIL()
{
ILEmitter emit = new ILEmitter();
ILCodeStream codeStream = emit.NewCodeStream();
if (Context.Target.IsWindows)
{
codeStream.MarkDebuggerStepThroughPoint();
}
for (int i = 0; i < Signature.Length; i++)
{
codeStream.EmitLdArg(i);
}
if (Context.Target.IsWindows)
{
codeStream.MarkDebuggerStepInPoint();
}
codeStream.Emit(ILOpcode.call, emit.NewToken(WrappedMethod));
codeStream.Emit(ILOpcode.ret);
return(emit.Link(this));
}
public override MethodIL EmitIL()
{
ILEmitter emit = new ILEmitter();
ILCodeStream codeStream = emit.NewCodeStream();
// We only need the initial step over sequence point if there's any instructions before the call.
if (Signature.Length > 0)
{
codeStream.MarkDebuggerStepThroughPoint();
}
for (int i = 0; i < Signature.Length; i++)
{
codeStream.EmitLdArg(i);
}
codeStream.MarkDebuggerStepInPoint();
codeStream.Emit(ILOpcode.call, emit.NewToken(WrappedMethod));
codeStream.Emit(ILOpcode.ret);
return(emit.Link(this));
}
public override MethodIL EmitIL()
{
ILEmitter emitter = new ILEmitter();
ILCodeStream codeStream = emitter.NewCodeStream();
codeStream.MarkDebuggerStepThroughPoint();
// Allow the class library to run explicitly ordered class constructors first thing in start-up.
if (_libraryInitializers != null)
{
foreach (MethodDesc method in _libraryInitializers)
{
codeStream.Emit(ILOpcode.call, emitter.NewToken(method));
}
}
MetadataType startup = Context.GetHelperType("StartupCodeHelpers");
// Initialize command line args if the class library supports this
string initArgsName = (Context.Target.OperatingSystem == TargetOS.Windows)
? "InitializeCommandLineArgsW"
: "InitializeCommandLineArgs";
MethodDesc initArgs = startup.GetMethod(initArgsName, null);
if (initArgs != null)
{
codeStream.Emit(ILOpcode.ldarg_0); // argc
codeStream.Emit(ILOpcode.ldarg_1); // argv
codeStream.Emit(ILOpcode.call, emitter.NewToken(initArgs));
}
// Initialize the entrypoint assembly if the class library supports this
MethodDesc initEntryAssembly = startup.GetMethod("InitializeEntryAssembly", null);
if (initEntryAssembly != null)
{
ModuleDesc entrypointModule = ((MetadataType)_mainMethod.WrappedMethod.OwningType).Module;
codeStream.Emit(ILOpcode.ldtoken, emitter.NewToken(entrypointModule.GetGlobalModuleType()));
codeStream.Emit(ILOpcode.call, emitter.NewToken(initEntryAssembly));
}
// Call program Main
if (_mainMethod.Signature.Length > 0)
{
// TODO: better exception
if (initArgs == null)
{
throw new Exception("Main() has parameters, but the class library doesn't support them");
}
codeStream.Emit(ILOpcode.call, emitter.NewToken(startup.GetKnownMethod("GetMainMethodArguments", null)));
}
codeStream.MarkDebuggerStepInPoint();
codeStream.Emit(ILOpcode.call, emitter.NewToken(_mainMethod));
MethodDesc setLatchedExitCode = startup.GetMethod("SetLatchedExitCode", null);
MethodDesc shutdown = startup.GetMethod("Shutdown", null);
// The class library either supports "advanced shutdown", or doesn't. No half-implementations allowed.
Debug.Assert((setLatchedExitCode != null) == (shutdown != null));
if (setLatchedExitCode != null)
{
// If the main method has a return value, save it
if (!_mainMethod.Signature.ReturnType.IsVoid)
{
codeStream.Emit(ILOpcode.call, emitter.NewToken(setLatchedExitCode));
}
// Ask the class library to shut down and return exit code.
codeStream.Emit(ILOpcode.call, emitter.NewToken(shutdown));
}
else
{
// This is a class library that doesn't have SetLatchedExitCode/Shutdown.
// If the main method returns void, we simply use 0 exit code.
if (_mainMethod.Signature.ReturnType.IsVoid)
{
codeStream.EmitLdc(0);
}
}
codeStream.Emit(ILOpcode.ret);
return(emitter.Link(this));
}